@levalicious/server-memory 0.0.12 → 0.0.14

package/dist/tests/memory-server.test.js

@@ -1027,4 +1027,133 @@ describe('MCP Memory Server E2E Tests', () => {
             });
         });
     });
+    describe('kb_load', () => {
+        let docFile;
+        beforeEach(async () => {
+            docFile = path.join(testDir, 'test-doc.txt');
+        });
+        it('should reject non-plaintext extensions', async () => {
+            const pdfPath = path.join(testDir, 'test.pdf');
+            await fs.writeFile(pdfPath, 'fake pdf content');
+            await expect(callTool(client, 'kb_load', { filePath: pdfPath })).rejects.toThrow(/Unsupported file extension/);
+        });
+        it('should reject files with no extension', async () => {
+            const noExtPath = path.join(testDir, 'noext');
+            await fs.writeFile(noExtPath, 'some content');
+            await expect(callTool(client, 'kb_load', { filePath: noExtPath })).rejects.toThrow(/no extension/);
+        });
+        it('should reject missing files', async () => {
+            await expect(callTool(client, 'kb_load', { filePath: path.join(testDir, 'nonexistent.txt') })).rejects.toThrow(/Failed to read file/);
+        });
+        it('should load a small document and create entities + relations', async () => {
+            const text = [
+                'Abstract interpretation is a theory of sound approximation of program semantics.',
+                'The key idea is to compute over abstract domains instead of concrete domains.',
+                'This enables static analysis to scale to large programs.',
+                'Galois connections formalize the relationship between abstract and concrete.',
+                'Widening operators ensure termination of the analysis.',
+            ].join(' ');
+            await fs.writeFile(docFile, text);
+            const result = await callTool(client, 'kb_load', { filePath: docFile });
+            expect(result.document).toBe('test-doc');
+            expect(result.entitiesCreated).toBeGreaterThan(0);
+            expect(result.relationsCreated).toBeGreaterThan(0);
+            expect(result.stats.chunks).toBeGreaterThan(0);
+            expect(result.stats.sentences).toBeGreaterThan(0);
+        });
+        it('should create Document, TextChunk, and DocumentIndex entities', async () => {
+            await fs.writeFile(docFile, 'The quick brown fox jumps over the lazy dog. The fox was very quick and the dog was very lazy. This sentence makes the document long enough to have multiple chunks for testing purposes and analysis.');
+            await callTool(client, 'kb_load', { filePath: docFile });
+            // Check document entity
+            const docResult = await callTool(client, 'open_nodes', { names: ['test-doc'] });
+            expect(docResult.entities.items).toHaveLength(1);
+            expect(docResult.entities.items[0].entityType).toBe('Document');
+            // Check index entity
+            const indexResult = await callTool(client, 'open_nodes', { names: ['test-doc__index'] });
+            expect(indexResult.entities.items).toHaveLength(1);
+            expect(indexResult.entities.items[0].entityType).toBe('DocumentIndex');
+            // Check TextChunk entities exist via type query
+            const chunks = await callTool(client, 'get_entities_by_type', { entityType: 'TextChunk' });
+            expect(chunks.items.length).toBeGreaterThan(0);
+            for (const chunk of chunks.items) {
+                expect(chunk.observations.length).toBeLessThanOrEqual(2);
+                for (const obs of chunk.observations) {
+                    expect(obs.length).toBeLessThanOrEqual(140);
+                }
+            }
+        });
+        it('should create chain relations (starts_with, ends_with, follows)', async () => {
+            const text = 'First sentence of the document goes here. ' +
+                'Second sentence adds more content to the document. ' +
+                'Third sentence continues the thought further along. ' +
+                'Fourth sentence wraps up the document nicely.';
+            await fs.writeFile(docFile, text);
+            await callTool(client, 'kb_load', { filePath: docFile });
+            // Get the document's relations
+            const docResult = await callTool(client, 'open_nodes', { names: ['test-doc'] });
+            const relTypes = docResult.relations.items.map(r => r.relationType);
+            expect(relTypes).toContain('starts_with');
+            expect(relTypes).toContain('has_index');
+        });
+        it('should create index → chunk highlight relations', async () => {
+            const sentences = [];
+            for (let i = 0; i < 20; i++) {
+                sentences.push(`This is sentence number ${i} about abstract interpretation and program analysis with different keywords each time.`);
+            }
+            await fs.writeFile(docFile, sentences.join(' '));
+            const result = await callTool(client, 'kb_load', { filePath: docFile });
+            expect(result.stats.indexHighlights).toBeGreaterThan(0);
+            // Open the index and verify it has highlight relations
+            const indexResult = await callTool(client, 'open_nodes', { names: ['test-doc__index'] });
+            const highlightRels = indexResult.relations.items.filter(r => r.relationType === 'highlights');
+            expect(highlightRels.length).toBeGreaterThan(0);
+        });
+        it('should respect custom title', async () => {
+            await fs.writeFile(docFile, 'Some document content that is long enough to process.');
+            const result = await callTool(client, 'kb_load', {
+                filePath: docFile,
+                title: 'my-custom-title',
+            });
+            expect(result.document).toBe('my-custom-title');
+            const docResult = await callTool(client, 'open_nodes', { names: ['my-custom-title'] });
+            expect(docResult.entities.items).toHaveLength(1);
+        });
+        it('should not create duplicate document entity on reload with different content', async () => {
+            await fs.writeFile(docFile, 'Short doc for dedup testing purposes here.');
+            await callTool(client, 'kb_load', { filePath: docFile });
+            // Second load with different content but same title — Document entity
+            // already exists with entityType 'Document' and no observations,
+            // so it gets silently skipped. But the index entity already exists
+            // with different observations, so it should error.
+            await fs.writeFile(docFile, 'Completely different content for dedup testing now.');
+            await expect(callTool(client, 'kb_load', { filePath: docFile })).rejects.toThrow(/already exists/);
+        });
+        it('should enforce observation length limits', async () => {
+            // Create a document with very long words that might challenge splitting
+            const longWord = 'a'.repeat(200);
+            await fs.writeFile(docFile, `${longWord} is a very long word that tests our splitting logic handles edge cases.`);
+            const result = await callTool(client, 'kb_load', { filePath: docFile });
+            expect(result.entitiesCreated).toBeGreaterThan(0);
+            // All observations should be within limits
+            const chunks = await callTool(client, 'get_entities_by_type', { entityType: 'TextChunk' });
+            for (const chunk of chunks.items) {
+                for (const obs of chunk.observations) {
+                    expect(obs.length).toBeLessThanOrEqual(140);
+                }
+            }
+        });
+        it('should accept various plaintext extensions', async () => {
+            const extensions = ['.txt', '.md', '.tex', '.py', '.ts', '.c'];
+            for (const ext of extensions) {
+                const filePath = path.join(testDir, `test${ext}`);
+                await fs.writeFile(filePath, 'Some plaintext content for extension testing purposes here.');
+                // Should not throw on validation — use a unique title per extension
+                const result = await callTool(client, 'kb_load', {
+                    filePath,
+                    title: `ext-test-${ext.slice(1)}`,
+                });
+                expect(result.entitiesCreated).toBeGreaterThan(0);
+            }
+        });
+    });
 });

package/dist/tests/test-utils.js

@@ -31,6 +31,12 @@ const PAGINATED_TOOLS = new Set([
     'get_orphaned_entities',
 ]);
 export async function callTool(client, name, args) {
+    // Verify tool is discoverable via ListTools before calling it
+    const listing = await client.listTools();
+    const toolNames = listing.tools.map((t) => t.name);
+    if (!toolNames.includes(name)) {
+        throw new Error(`Tool "${name}" is not listed in ListTools. Available: ${toolNames.join(', ')}`);
+    }
     const result = await client.callTool({ name, arguments: args });
     const content = result.content;
     if (!content || content.length === 0) {

package/native/binding.c

@@ -0,0 +1,340 @@
+/*
+ * N-API binding for memoryfile
+ *
+ * Exposes the C memoryfile allocator to Node.js.
+ * Each MemoryFile handle is wrapped in a pointerless external.
+ */
+
+#define NAPI_VERSION 8
+#include <node_api.h>
+#include <stdlib.h>
+#include <string.h>
+#include "memoryfile.h"
+
+/* =========================================================================
+ * Helpers
+ * ========================================================================= */
+
+#define NAPI_CALL(call)                                                    \
+    do {                                                                   \
+        napi_status status = (call);                                       \
+        if (status != napi_ok) {                                           \
+            napi_throw_error(env, NULL, "N-API call failed: " #call);      \
+            return NULL;                                                   \
+        }                                                                  \
+    } while (0)
+
+static napi_value make_u64(napi_env env, u64 val) {
+    /* Use BigInt for u64 to avoid precision loss */
+    napi_value result;
+    NAPI_CALL(napi_create_bigint_uint64(env, val, &result));
+    return result;
+}
+
+static u64 get_u64(napi_env env, napi_value val) {
+    bool lossless;
+    uint64_t result;
+    napi_get_value_bigint_uint64(env, val, &result, &lossless);
+    return result;
+}
+
+static void mf_release(napi_env env, void *data, void *hint) {
+    (void)env; (void)hint;
+    memfile_t *mf = (memfile_t*)data;
+    if (mf) {
+        memfile_close(mf);  /* no-op if already closed */
+        mf->mmap_base = NULL;
+        mf->header = NULL;
+        free(mf);
+    }
+}
+
+static memfile_t *unwrap_mf(napi_env env, napi_value val) {
+    memfile_t *mf;
+    napi_get_value_external(env, val, (void**)&mf);
+    return mf;
+}
+
+/* =========================================================================
+ * memfile_open(path: string, initialSize: number) => external
+ * ========================================================================= */
+
+static napi_value n_memfile_open(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    /* Get path string */
+    char path[4096];
+    size_t path_len;
+    NAPI_CALL(napi_get_value_string_utf8(env, argv[0], path, sizeof(path), &path_len));
+
+    /* Get initial size */
+    uint32_t initial_size;
+    NAPI_CALL(napi_get_value_uint32(env, argv[1], &initial_size));
+
+    memfile_t *mf = memfile_open(path, (size_t)initial_size);
+    if (!mf) {
+        napi_throw_error(env, NULL, "memfile_open failed");
+        return NULL;
+    }
+
+    napi_value result;
+    NAPI_CALL(napi_create_external(env, mf, mf_release, NULL, &result));
+    return result;
+}
+
+/* =========================================================================
+ * memfile_close(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_close(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_close(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_sync(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_sync(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_sync(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_alloc(handle: external, size: bigint) => bigint (offset)
+ * ========================================================================= */
+
+static napi_value n_memfile_alloc(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 size = get_u64(env, argv[1]);
+
+    u64 offset = memfile_alloc(mf, size);
+    return make_u64(env, offset);
+}
+
+/* =========================================================================
+ * memfile_free(handle: external, offset: bigint) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_free(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+
+    memfile_free(mf, offset);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_coalesce(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_coalesce(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_coalesce(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_read(handle: external, offset: bigint, length: bigint) => Buffer
+ * ========================================================================= */
+
+static napi_value n_memfile_read(napi_env env, napi_callback_info info) {
+    size_t argc = 3;
+    napi_value argv[3];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+    u64 len = get_u64(env, argv[2]);
+
+    /* Create a Node Buffer and copy data into it */
+    void *buf_data;
+    napi_value result;
+    NAPI_CALL(napi_create_buffer(env, (size_t)len, &buf_data, &result));
+
+    if (memfile_read(mf, offset, buf_data, len) < 0) {
+        napi_throw_error(env, NULL, "memfile_read: offset/length out of bounds");
+        return NULL;
+    }
+
+    return result;
+}
+
+/* =========================================================================
+ * memfile_write(handle: external, offset: bigint, data: Buffer) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_write(napi_env env, napi_callback_info info) {
+    size_t argc = 3;
+    napi_value argv[3];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+
+    /* Get Buffer data */
+    void *buf_data;
+    size_t buf_len;
+    NAPI_CALL(napi_get_buffer_info(env, argv[2], &buf_data, &buf_len));
+
+    if (memfile_write(mf, offset, buf_data, buf_len) < 0) {
+        napi_throw_error(env, NULL, "memfile_write: offset/length out of bounds");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_lock_shared(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_lock_shared(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_lock_shared(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_lock_shared failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_lock_exclusive(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_lock_exclusive(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_lock_exclusive(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_lock_exclusive failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_unlock(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_unlock(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_unlock(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_unlock failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_stats(handle: external) => { fileSize, allocated, freeListHead }
+ * ========================================================================= */
+
+static napi_value n_memfile_stats(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+
+    napi_value result;
+    NAPI_CALL(napi_create_object(env, &result));
+
+    napi_value v;
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->file_size, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "fileSize", v));
+
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->allocated, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "allocated", v));
+
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->free_list_head, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "freeListHead", v));
+
+    return result;
+}
+
+/* =========================================================================
+ * memfile_refresh(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_refresh(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_refresh(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_refresh failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * Module init
+ * ========================================================================= */
+
+#define EXPORT_FN(name, fn) do {                                               \
+    napi_value _fn;                                                            \
+    napi_create_function(env, name, NAPI_AUTO_LENGTH, fn, NULL, &_fn);         \
+    napi_set_named_property(env, exports, name, _fn);                          \
+} while(0)
+
+NAPI_MODULE_INIT(/* napi_env env, napi_value exports */) {
+    EXPORT_FN("open",          n_memfile_open);
+    EXPORT_FN("close",         n_memfile_close);
+    EXPORT_FN("sync",          n_memfile_sync);
+    EXPORT_FN("alloc",         n_memfile_alloc);
+    EXPORT_FN("free",          n_memfile_free);
+    EXPORT_FN("coalesce",      n_memfile_coalesce);
+    EXPORT_FN("read",          n_memfile_read);
+    EXPORT_FN("write",         n_memfile_write);
+    EXPORT_FN("lockShared",    n_memfile_lock_shared);
+    EXPORT_FN("lockExclusive", n_memfile_lock_exclusive);
+    EXPORT_FN("unlock",        n_memfile_unlock);
+    EXPORT_FN("stats",         n_memfile_stats);
+    EXPORT_FN("refresh",       n_memfile_refresh);
+    return exports;
+}