wyrm-mcp 7.3.2 → 7.3.3

package/dist/icons.js

@@ -1 +1,47 @@
-const e={brand:process.env.WYRM_BRAND??"\u{F115D}",session:"\u2307",toolCall:"\u2699",questOpen:"\u27F6",questDone:"\u27DC",blocked:"\u2716",truth:"\u2B22",memory:"\u2731",reference:"\u2727",federation:"\u21AF",failure:"\u26A0",celebrate:"\u273A",encryption:"\u22A0",ok:"\u2713",pending:"\u25CC",active:"\u25CF",inactive:"\u25CB",point:"\u25B8",bullet:"\xB7",divider:"\u2500"};export{e as ICON};
+/**
+ * Wyrm iconography (5.10.0 — PhantomDragon brand alignment).
+ *
+ * Curated Unicode glyphs that match the Ghost Protocol / PhantomDragon
+ * visual lineage — sharp, geometric, serpentine — instead of the
+ * grab-bag of generic emoji that accreted across earlier releases.
+ *
+ * The brand mark is a Nerd Font dragon glyph (NOT a dragon emoji) — it reads as
+ * the Ghost Protocol silver dragon when rendered in silver in the statusline,
+ * and degrades to a box on terminals without a Nerd Font. Override the glyph
+ * with `WYRM_BRAND` (e.g. a wordmark, a different codepoint, or '' for none).
+ *
+ * Use these constants by name everywhere instead of hard-coding glyphs
+ * — keeps the visual surface centrally tunable.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+export const ICON = {
+    // The brand mark — Nerd Font dragon glyph (silver in the statusline), NOT an
+    // emoji. Override with WYRM_BRAND. Default codepoint U+F115D renders a dragon
+    // on Nerd Fonts (Material Design Icons range).
+    brand: process.env.WYRM_BRAND ?? '\u{f115d}',
+    // Activity glyphs
+    session: '⌇', // serpentine wave — sessions are coiled time
+    toolCall: '⚙', // gear — tool invocations
+    questOpen: '⟶', // arrow — quest in progress / pending
+    questDone: '⟜', // tack-bar — quest completed (sealed)
+    blocked: '✖', // x-mark — failure check blocked an attempt
+    truth: '⬢', // hexagon — ground truth (matches constitution sigil)
+    memory: '✱', // asterisk-star — memory artifact
+    reference: '✧', // sparkle — design reference / inspiration
+    federation: '↯', // lightning — buddy / outbound federation
+    failure: '⚠', // warning — unresolved failure
+    celebrate: '✺', // burst-star — milestone hit
+    encryption: '⊠', // boxed-x — encrypted at rest (was 🔒)
+    // Status glyphs
+    ok: '✓', // light check — generic success
+    pending: '◌', // dotted circle — pending state
+    active: '●', // filled dot — active state
+    inactive: '○', // empty circle — inactive state
+    // Structural glyphs (markdown headings, callouts)
+    point: '▸', // pointer — bullet for high-emphasis lists
+    bullet: '·', // mid-dot — bullet for normal lists
+    divider: '─', // box-drawing horizontal
+};
+//# sourceMappingURL=icons.js.map

package/dist/importers.js

@@ -1 +1,268 @@
-function m(e){return Array.isArray(e)?e:[]}function c(e){return e&&typeof e=="object"&&!Array.isArray(e)?e:{}}function u(e){if(typeof e!="string")return null;const t=e.trim();return t.length>0?t:null}function d(e,t){if(Array.isArray(e))return e;const n=c(e);for(const r of t)if(Array.isArray(n[r]))return n[r];return[]}function p(e){const t={};for(const[n,r]of Object.entries(e))r==null||r===""||(t[n]=r);return Object.keys(t).length>0?t:void 0}function y(e){const t=d(e,["results","memories","data","records","items"]),n=[];for(const r of t){const o=c(r),a=u(o.memory??o.text);if(!a)continue;const s=["imported_from:mem0"];for(const l of["user_id","agent_id","run_id"]){const f=u(o[l]);f&&s.push(`${l}:${f}`)}const i=p({...c(o.metadata),mem0_id:o.id,created_at:o.created_at});n.push({text:a,tags:s,source:"mem0",metadata:i})}return n}function _(e){if(typeof e=="string")return u(e);const t=c(e);return u(t.fact??t.content??t.memory??t.text)}function g(e){const t=c(e);return p({role:t.role,created_at:t.created_at,name:t.name,uuid:t.uuid??t.id})}function h(e){const t=c(e),n=c(t.memory),r=c(t.graph),o=[...m(e),...m(t.facts),...m(n.facts),...m(t.relevant_facts),...m(t.messages),...m(n.messages),...m(t.edges),...m(r.edges)],a=[];for(const s of o){const i=_(s);i&&a.push({text:i,tags:["imported_from:zep"],source:"zep",metadata:g(s)})}return a}function x(e){const t=d(e,["memories","documents","results","data","records","items"]),n=[];for(const r of t){const o=c(r),a=u(o.content??o.memory??o.text);if(!a)continue;const s=["imported_from:supermemory"];for(const l of[...m(o.tags),...m(o.containerTags)]){const f=u(l);f&&s.push(f)}const i=p({...c(o.metadata),supermemory_id:o.id,created_at:o.createdAt??o.created_at});n.push({text:a,tags:s,source:"supermemory",metadata:i})}return n}function b(e){const t=[];if(Array.isArray(e))for(const n of e){const r=c(n),o=u(r.label??r.name)??"block",a=u(r.value??r.text??r.content);a&&t.push({label:o,text:a})}else for(const[n,r]of Object.entries(c(e))){const o=u(r)??u(c(r).value??c(r).text);o&&t.push({label:n,text:o})}return t}function k(e){const t=c(e),n=c(t.memory),r=[],o=t.core_memory??n.blocks??t.blocks??t.memory_blocks??n.core_memory;for(const{label:s,text:i}of b(o))r.push({text:i,tags:["imported_from:letta",`block:${s}`],source:"letta",metadata:p({block:s,memory_type:"core"})});const a=[...m(t.archival_memory),...m(t.archival),...m(n.archival_memory)];for(const s of a){const i=u(typeof s=="string"?s:c(s).text??c(s).content);i&&r.push({text:i,tags:["imported_from:letta","memory:archival"],source:"letta",metadata:p({memory_type:"archival"})})}return r}const w=["mem0","zep","supermemory","letta"];function A(e,t){switch(String(e??"").trim().toLowerCase()){case"mem0":return y(t);case"zep":return h(t);case"supermemory":return x(t);case"letta":case"memgpt":return k(t);default:throw new Error(`wyrm import: unknown source "${e}". Supported: ${w.join(", ")} (memgpt = letta).`)}}export{w as IMPORT_SOURCES,A as importFrom,k as importLetta,y as importMem0,x as importSupermemory,h as importZep};
+/**
+ * `wyrm import` — foreign-memory IMPORT mappers.
+ *
+ * Pure functions that take a parsed memory export from a RIVAL system
+ * (mem0 / Zep / Supermemory / Letta·MemGPT) and normalise it into
+ * {@link ImportedMemory}[] — so a team can leave a rival and ARRIVE in Wyrm
+ * with their memories intact (and, once vetted via the review queue, upgraded
+ * with Wyrm's negative learning + signed provenance). This migrates the DATA;
+ * the sibling `@wyrm/mem0-compat` swaps the SDK.
+ *
+ * Discipline:
+ *   - HONEST: each mapper handles the documented/common export shape AND
+ *     tolerates the reasonable wrapper variants (a bare array vs `{results}` /
+ *     `{memories}` / `{documents}` / `{data}` / `{facts}` / `{messages}`).
+ *   - NEVER FABRICATE: a record with no extractable text is SKIPPED, not
+ *     invented. Empty/blank text is dropped.
+ *   - The exact wire shapes of these proprietary exports are not all formally
+ *     documented; where a shape is uncertain the assumption is noted inline and
+ *     the mapper degrades gracefully (returns [] for an unrecognised payload)
+ *     rather than throwing.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+// ============================================================================
+// Small, defensive shape helpers — every export is `unknown` from JSON.parse.
+// ============================================================================
+function asArray(v) {
+    return Array.isArray(v) ? v : [];
+}
+function asObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+/** Trim a candidate to non-empty text, or null when there is nothing to store. */
+function cleanText(v) {
+    if (typeof v !== 'string')
+        return null;
+    const s = v.trim();
+    return s.length > 0 ? s : null;
+}
+/**
+ * Unwrap the records array from an export that may be a bare array OR an object
+ * wrapping the array under one of several common keys.
+ */
+function unwrap(json, keys) {
+    if (Array.isArray(json))
+        return json;
+    const obj = asObject(json);
+    for (const k of keys) {
+        if (Array.isArray(obj[k]))
+            return obj[k];
+    }
+    return [];
+}
+/** Build a metadata object from the supplied entries, dropping undefined/null/''. */
+function collectMeta(entries) {
+    const out = {};
+    for (const [k, v] of Object.entries(entries)) {
+        if (v === undefined || v === null || v === '')
+            continue;
+        out[k] = v;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+// ============================================================================
+// mem0
+// ============================================================================
+/**
+ * mem0 export — an array (or `{results:[...]}`) of:
+ *   { id, memory, user_id?/agent_id?/run_id?, metadata?, created_at? }
+ * `text` = `memory` (tolerating a `text` alias); the mem0 scope ids become
+ * tags so the per-scope isolation carries over; `imported_from:mem0` is added.
+ */
+export function importMem0(json) {
+    const records = unwrap(json, ['results', 'memories', 'data', 'records', 'items']);
+    const out = [];
+    for (const raw of records) {
+        const rec = asObject(raw);
+        const text = cleanText(rec.memory ?? rec.text);
+        if (!text)
+            continue; // never fabricate a memory
+        const tags = ['imported_from:mem0'];
+        for (const k of ['user_id', 'agent_id', 'run_id']) {
+            const v = cleanText(rec[k]);
+            if (v)
+                tags.push(`${k}:${v}`);
+        }
+        const metadata = collectMeta({
+            ...asObject(rec.metadata),
+            mem0_id: rec.id,
+            created_at: rec.created_at,
+        });
+        out.push({ text, tags, source: 'mem0', metadata });
+    }
+    return out;
+}
+// ============================================================================
+// Zep
+// ============================================================================
+/** Pull memory text out of a Zep fact/message/edge (object or bare string). */
+function zepText(item) {
+    if (typeof item === 'string')
+        return cleanText(item);
+    const obj = asObject(item);
+    // fact (knowledge graph) → content (message) → memory/text aliases.
+    return cleanText(obj.fact ?? obj.content ?? obj.memory ?? obj.text);
+}
+function zepMeta(item) {
+    const obj = asObject(item);
+    return collectMeta({
+        role: obj.role,
+        created_at: obj.created_at,
+        name: obj.name,
+        uuid: obj.uuid ?? obj.id,
+    });
+}
+/**
+ * Zep export — facts and/or messages and/or a knowledge graph of edges. Zep's
+ * surfaces vary by API version, so this gathers from every common location:
+ *   - `facts[]` / `memory.facts[]` / `relevant_facts[]`  (objects `{fact|content}` or strings)
+ *   - `messages[]` / `memory.messages[]`                 (`{role, content}`)
+ *   - `edges[]` / `graph.edges[]`                         (graph edges `{fact}`)
+ *   - a bare top-level array (each item probed for fact/content/memory/text)
+ * Every mapped item is tagged `imported_from:zep`.
+ */
+export function importZep(json) {
+    const root = asObject(json);
+    const memory = asObject(root.memory);
+    const graph = asObject(root.graph);
+    const items = [
+        ...asArray(json), // bare top-level array
+        ...asArray(root.facts),
+        ...asArray(memory.facts),
+        ...asArray(root.relevant_facts),
+        ...asArray(root.messages),
+        ...asArray(memory.messages),
+        ...asArray(root.edges),
+        ...asArray(graph.edges),
+    ];
+    const out = [];
+    for (const item of items) {
+        const text = zepText(item);
+        if (!text)
+            continue;
+        out.push({ text, tags: ['imported_from:zep'], source: 'zep', metadata: zepMeta(item) });
+    }
+    return out;
+}
+// ============================================================================
+// Supermemory
+// ============================================================================
+/**
+ * Supermemory export — `memories`/`documents` (or `results`/`data`, or a bare
+ * array) of `{ content | memory | text, metadata?, tags? }`. `text` = `content`
+ * (with `memory`/`text` aliases); `imported_from:supermemory` is added, and any
+ * string `tags`/`containerTags` on the record are carried through.
+ */
+export function importSupermemory(json) {
+    const records = unwrap(json, ['memories', 'documents', 'results', 'data', 'records', 'items']);
+    const out = [];
+    for (const raw of records) {
+        const rec = asObject(raw);
+        const text = cleanText(rec.content ?? rec.memory ?? rec.text);
+        if (!text)
+            continue;
+        const tags = ['imported_from:supermemory'];
+        for (const t of [...asArray(rec.tags), ...asArray(rec.containerTags)]) {
+            const tv = cleanText(t);
+            if (tv)
+                tags.push(tv);
+        }
+        const metadata = collectMeta({
+            ...asObject(rec.metadata),
+            supermemory_id: rec.id,
+            created_at: rec.createdAt ?? rec.created_at,
+        });
+        out.push({ text, tags, source: 'supermemory', metadata });
+    }
+    return out;
+}
+// ============================================================================
+// Letta / MemGPT
+// ============================================================================
+/** Read a Letta core-memory container into [label, text] block pairs. The
+ *  container is either an object whose VALUES are the block text (classic
+ *  MemGPT `{human, persona}`) or an array of block objects `{label|name, value|text}`. */
+function lettaBlocks(container) {
+    const blocks = [];
+    if (Array.isArray(container)) {
+        for (const raw of container) {
+            const b = asObject(raw);
+            const label = cleanText(b.label ?? b.name) ?? 'block';
+            const text = cleanText(b.value ?? b.text ?? b.content);
+            if (text)
+                blocks.push({ label, text });
+        }
+    }
+    else {
+        for (const [label, raw] of Object.entries(asObject(container))) {
+            // value may be the block text directly, or a `{value|text}` object.
+            const text = cleanText(raw) ?? cleanText(asObject(raw).value ?? asObject(raw).text);
+            if (text)
+                blocks.push({ label, text });
+        }
+    }
+    return blocks;
+}
+/**
+ * Letta/MemGPT export — an agent's memory: core memory blocks + archival memory.
+ *   - core blocks: `core_memory` | `memory.blocks` | `blocks` | `memory_blocks`
+ *     (classic `{human, persona}` object OR an array of `{label, value}` blocks)
+ *   - archival: `archival_memory[]` | `archival[]` (`{text|content}` or strings)
+ * Core blocks are tagged `block:<label>`; everything gets `imported_from:letta`.
+ */
+export function importLetta(json) {
+    const root = asObject(json);
+    const memory = asObject(root.memory);
+    const out = [];
+    const coreContainer = root.core_memory ?? memory.blocks ?? root.blocks ?? root.memory_blocks ?? memory.core_memory;
+    for (const { label, text } of lettaBlocks(coreContainer)) {
+        out.push({
+            text,
+            tags: ['imported_from:letta', `block:${label}`],
+            source: 'letta',
+            metadata: collectMeta({ block: label, memory_type: 'core' }),
+        });
+    }
+    const archival = [...asArray(root.archival_memory), ...asArray(root.archival), ...asArray(memory.archival_memory)];
+    for (const raw of archival) {
+        const text = typeof raw === 'string' ? cleanText(raw) : cleanText(asObject(raw).text ?? asObject(raw).content);
+        if (!text)
+            continue;
+        out.push({
+            text,
+            tags: ['imported_from:letta', 'memory:archival'],
+            source: 'letta',
+            metadata: collectMeta({ memory_type: 'archival' }),
+        });
+    }
+    return out;
+}
+// ============================================================================
+// Dispatcher
+// ============================================================================
+/** The rival sources `wyrm import --from` understands. */
+export const IMPORT_SOURCES = ['mem0', 'zep', 'supermemory', 'letta'];
+/**
+ * Route a parsed export to its mapper by `source`. Case- and whitespace-
+ * insensitive; `memgpt` is accepted as an alias for `letta`. Throws a clear
+ * Error for an unknown source.
+ */
+export function importFrom(source, json) {
+    const key = String(source ?? '').trim().toLowerCase();
+    switch (key) {
+        case 'mem0':
+            return importMem0(json);
+        case 'zep':
+            return importZep(json);
+        case 'supermemory':
+            return importSupermemory(json);
+        case 'letta':
+        case 'memgpt':
+            return importLetta(json);
+        default:
+            throw new Error(`wyrm import: unknown source "${source}". Supported: ${IMPORT_SOURCES.join(', ')} (memgpt = letta).`);
+    }
+}
+//# sourceMappingURL=importers.js.map