@vheins/local-memory-mcp 0.1.4 → 0.1.5

package/dist/dashboard/dashboard.test.js

@@ -0,0 +1,362 @@
+// Feature: Dashboard Filter & Export Property Tests
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fc from "fast-check";
+describe("Property 12: Dashboard filter logic correctness", () => {
+    // Mock memory data generator
+    function generateMemories(count) {
+        const types = ["code_fact", "decision", "mistake", "pattern"];
+        return Array.from({ length: count }, (_, i) => ({
+            id: `test-${i}`,
+            type: types[i % types.length],
+            content: `Test memory content ${i} with some keywords`,
+            importance: (i % 5) + 1,
+            hit_count: i * 2,
+            recall_rate: i > 0 ? i / (i + 1) : 0,
+            created_at: new Date(Date.now() - i * 86400000).toISOString(),
+        }));
+    }
+    // Filter function (same as in dashboard)
+    function applyFilters(memories, searchQuery, typeFilter, minImportance, maxImportance) {
+        let filtered = [...memories];
+        if (searchQuery) {
+            const q = searchQuery.toLowerCase();
+            filtered = filtered.filter((m) => m.content.toLowerCase().includes(q) ||
+                m.type.toLowerCase().includes(q));
+        }
+        if (typeFilter) {
+            filtered = filtered.filter((m) => m.type === typeFilter);
+        }
+        if (minImportance > 0) {
+            filtered = filtered.filter((m) => m.importance >= minImportance);
+        }
+        if (maxImportance < 5) {
+            filtered = filtered.filter((m) => m.importance <= maxImportance);
+        }
+        return filtered;
+    }
+    it("property: search filter returns subset containing search term", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 10, maxLength: 100 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+            hit_count: fc.integer({ min: 0, max: 100 }),
+        })), fc.string({ minLength: 1, maxLength: 20 }), (memories, query) => {
+            if (memories.length === 0)
+                return true;
+            const filtered = applyFilters(memories, query, "", 0, 5);
+            // All results should contain query (if any returned)
+            for (const m of filtered) {
+                const containsQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
+                    m.type.toLowerCase().includes(query.toLowerCase());
+                expect(containsQuery).toBe(true);
+            }
+            // Filtered should not be larger than original
+            expect(filtered.length).toBeLessThanOrEqual(memories.length);
+        }), { numRuns: 50 });
+    });
+    it("property: type filter returns only matching types", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 10, maxLength: 100 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+        })), fc.constantFrom("", "code_fact", "decision", "mistake", "pattern"), (memories, typeFilter) => {
+            const filtered = applyFilters(memories, "", typeFilter, 0, 5);
+            if (typeFilter === "") {
+                // No filter should return all
+                expect(filtered.length).toBe(memories.length);
+            }
+            else {
+                // All results should have matching type
+                for (const m of filtered) {
+                    expect(m.type).toBe(typeFilter);
+                }
+            }
+        }), { numRuns: 50 });
+    });
+    it("property: importance range filter returns correct subset", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 10 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+        })), fc.integer({ min: 0, max: 5 }), fc.integer({ min: 0, max: 5 }), (memories, minImp, maxImp) => {
+            const safeMin = Math.min(minImp, maxImp);
+            const safeMax = Math.max(minImp, maxImp);
+            const filtered = applyFilters(memories, "", "", safeMin, safeMax);
+            for (const m of filtered) {
+                expect(m.importance).toBeGreaterThanOrEqual(safeMin);
+                expect(m.importance).toBeLessThanOrEqual(safeMax);
+            }
+        }), { numRuns: 50 });
+    });
+    it("property: combination filters are additive (AND logic)", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 10 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+        })), fc.string({ maxLength: 10 }), fc.constantFrom("", "code_fact", "decision"), fc.integer({ min: 1, max: 3 }), fc.integer({ min: 3, max: 5 }), (memories, search, type, minImp, maxImp) => {
+            const safeMin = Math.min(minImp, maxImp);
+            const safeMax = Math.max(minImp, maxImp);
+            const filtered = applyFilters(memories, search, type, safeMin, safeMax);
+            // Verify each result matches ALL criteria
+            for (const m of filtered) {
+                if (search) {
+                    expect(m.content.toLowerCase().includes(search.toLowerCase()) ||
+                        m.type.toLowerCase().includes(search.toLowerCase())).toBe(true);
+                }
+                if (type) {
+                    expect(m.type).toBe(type);
+                }
+                expect(m.importance).toBeGreaterThanOrEqual(safeMin);
+                expect(m.importance).toBeLessThanOrEqual(safeMax);
+            }
+        }), { numRuns: 30 });
+    });
+});
+describe("Property 13: Pagination non-overlapping", () => {
+    function paginate(items, page, pageSize) {
+        const start = (page - 1) * pageSize;
+        return items.slice(start, start + pageSize);
+    }
+    it("property: different pages have no overlapping IDs", () => {
+        fc.assert(fc.property(fc.array(fc.uuid(), { minLength: 10, maxLength: 100 }), fc.integer({ min: 1, max: 10 }), (ids, pageSize) => {
+            if (pageSize < 1)
+                return true;
+            const page1 = paginate(ids, 1, pageSize);
+            const page2 = paginate(ids, 2, pageSize);
+            // No common IDs between pages
+            const overlap = page1.filter((id) => page2.includes(id));
+            expect(overlap.length).toBe(0);
+        }), { numRuns: 50 });
+    });
+    it("property: all items appear in exactly one page", () => {
+        fc.assert(fc.property(fc.array(fc.integer(), { minLength: 1, maxLength: 50 }), fc.integer({ min: 1, max: 10 }), (items, pageSize) => {
+            if (pageSize < 1)
+                return true;
+            if (items.length === 0)
+                return true;
+            const totalPages = Math.ceil(items.length / pageSize);
+            const allPages = [];
+            for (let page = 1; page <= totalPages; page++) {
+                const pageItems = paginate(items, page, pageSize);
+                allPages.push(...pageItems);
+            }
+            // Should have same total count
+            expect(allPages.length).toBe(items.length);
+        }), { numRuns: 30 });
+    });
+});
+describe("Property 14: Export format correctness", () => {
+    function exportToCsv(memories) {
+        const headers = ["id", "type", "content", "importance", "hit_count", "created_at"];
+        const csvRows = [headers.join(",")];
+        for (const m of memories) {
+            const row = [
+                m.id,
+                m.type,
+                `"${m.content.replace(/"/g, '""')}"`,
+                m.importance,
+                m.hit_count,
+                m.created_at,
+            ];
+            csvRows.push(row.join(","));
+        }
+        return csvRows.join("\n");
+    }
+    function exportToJson(memories) {
+        return JSON.stringify(memories, null, 2);
+    }
+    it("property: CSV export contains all filtered data", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 5, maxLength: 50 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+            hit_count: fc.integer({ min: 0, max: 20 }),
+            created_at: fc.date().map((d) => d.toISOString()),
+        })), (memories) => {
+            if (memories.length === 0)
+                return;
+            const csv = exportToCsv(memories);
+            const lines = csv.split("\n");
+            // Header + data rows
+            expect(lines.length).toBe(memories.length + 1);
+            // Each row has 6 columns
+            for (let i = 1; i < lines.length; i++) {
+                const cols = lines[i].split(",");
+                expect(cols.length).toBeGreaterThanOrEqual(5);
+            }
+        }), { numRuns: 30, endOnFailure: true });
+    });
+    it("property: JSON export is valid parseable JSON", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("code_fact", "decision", "mistake", "pattern"),
+            content: fc.string({ minLength: 5 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+            hit_count: fc.integer({ min: 0, max: 10 }),
+            created_at: fc.string(),
+        })), (memories) => {
+            const json = exportToJson(memories);
+            const parsed = JSON.parse(json);
+            expect(Array.isArray(parsed)).toBe(true);
+            expect(parsed.length).toBe(memories.length);
+        }), { numRuns: 30 });
+    });
+    it("property: export respects filter (matches displayed data)", () => {
+        fc.assert(fc.property(fc.array(fc.record({
+            id: fc.uuid(),
+            type: fc.constantFrom("decision", "mistake", "code_fact", "pattern"),
+            content: fc.string({ minLength: 10 }),
+            importance: fc.integer({ min: 1, max: 5 }),
+            hit_count: fc.integer({ min: 0, max: 100 }),
+            created_at: fc.date({ min: new Date("2020-01-01"), max: new Date("2030-12-31") }).map((d) => d.toISOString()),
+        })), fc.constantFrom("decision", "mistake", "code_fact", "pattern"), (memories, typeFilter) => {
+            // Apply filter (same as dashboard)
+            const filtered = memories.filter((m) => m.type === typeFilter);
+            const csv = exportToCsv(filtered);
+            const json = exportToJson(filtered);
+            // CSV should have filtered count + 1 header
+            expect(csv.split("\n").length).toBe(filtered.length + 1);
+            // JSON should parse to filtered array
+            const parsed = JSON.parse(json);
+            expect(parsed.length).toBe(filtered.length);
+        }), { numRuns: 30 });
+    });
+});
+describe("Property 15: localStorage preferences round-trip", () => {
+    // Mock localStorage for Node.js environment
+    let mockStorage = {};
+    beforeEach(() => {
+        mockStorage = {};
+        global.localStorage = {
+            getItem: (key) => mockStorage[key] || null,
+            setItem: (key, value) => { mockStorage[key] = value; },
+            removeItem: (key) => { delete mockStorage[key]; },
+            clear: () => { mockStorage = {}; },
+            get length() { return Object.keys(mockStorage).length; },
+            key: (i) => Object.keys(mockStorage)[i] || null,
+        };
+    });
+    afterEach(() => {
+        delete global.localStorage;
+    });
+    function savePrefs(prefs) {
+        localStorage.setItem("dashboard_prefs", JSON.stringify(prefs));
+    }
+    function loadPrefs() {
+        const stored = localStorage.getItem("dashboard_prefs");
+        return stored ? JSON.parse(stored) : null;
+    }
+    it("property: saved preferences can be loaded identically", () => {
+        fc.assert(fc.property(fc.record({
+            theme: fc.constantFrom("light", "dark"),
+            pageSize: fc.constantFrom(10, 25, 50, 100),
+            columnVisibility: fc.record({ id: fc.boolean(), type: fc.boolean(), content: fc.boolean() }),
+            columnWidths: fc.record({ id: fc.integer({ min: 50, max: 300 }), type: fc.integer({ min: 50, max: 300 }) }),
+        }), (prefs) => {
+            savePrefs(prefs);
+            const loaded = loadPrefs();
+            expect(loaded).not.toBeNull();
+            expect(loaded?.theme).toBe(prefs.theme);
+            expect(loaded?.pageSize).toBe(prefs.pageSize);
+        }), { numRuns: 30 });
+    });
+});
+describe("Property 16: Recent Queries feature", () => {
+    let mockStorage = {};
+    beforeEach(() => {
+        mockStorage = {};
+        global.localStorage = {
+            getItem: (key) => mockStorage[key] || null,
+            setItem: (key, value) => { mockStorage[key] = value; },
+            removeItem: (key) => { delete mockStorage[key]; },
+            clear: () => { mockStorage = {}; },
+            get length() { return Object.keys(mockStorage).length; },
+            key: (i) => Object.keys(mockStorage)[i] || null,
+        };
+    });
+    afterEach(() => {
+        delete global.localStorage;
+    });
+    // Simulate recent queries stored in localStorage (fallback)
+    function getRecentQueriesFromStorage() {
+        const stored = localStorage.getItem("recentQueries");
+        return stored ? JSON.parse(stored) : [];
+    }
+    function addRecentQueryToStorage(query) {
+        if (!query.trim())
+            return;
+        const queries = getRecentQueriesFromStorage();
+        const filtered = queries.filter(q => q !== query);
+        filtered.unshift(query);
+        const limited = filtered.slice(0, 20);
+        localStorage.setItem("recentQueries", JSON.stringify(limited));
+    }
+    it("property: adding query moves it to front and removes duplicates", () => {
+        addRecentQueryToStorage("database");
+        addRecentQueryToStorage("authentication");
+        addRecentQueryToStorage("database"); // duplicate - should move to front
+        const queries = getRecentQueriesFromStorage();
+        expect(queries[0]).toBe("database");
+        expect(queries[1]).toBe("authentication");
+        expect(queries.length).toBe(2);
+    });
+    it("property: recent queries are limited to 20", () => {
+        for (let i = 0; i < 25; i++) {
+            addRecentQueryToStorage(`query-${i}`);
+        }
+        const queries = getRecentQueriesFromStorage();
+        expect(queries.length).toBe(20);
+        expect(queries[0]).toBe("query-24");
+        expect(queries[19]).toBe("query-5");
+    });
+    it("property: empty query is not added", () => {
+        addRecentQueryToStorage("valid-query");
+        addRecentQueryToStorage("");
+        addRecentQueryToStorage("   ");
+        const queries = getRecentQueriesFromStorage();
+        expect(queries.length).toBe(1);
+        expect(queries[0]).toBe("valid-query");
+    });
+    it("property: queries maintain insertion order with unique constraint", () => {
+        addRecentQueryToStorage("first");
+        addRecentQueryToStorage("second");
+        addRecentQueryToStorage("third");
+        addRecentQueryToStorage("first"); // move to front
+        addRecentQueryToStorage("second"); // move to front
+        const queries = getRecentQueriesFromStorage();
+        expect(queries).toEqual(["second", "first", "third"]);
+    });
+});
+describe("Property 17: Recent Queries API response format", () => {
+    function parseRecentQueriesResponse(json) {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed.queries)) {
+            throw new Error("Invalid response: queries must be an array");
+        }
+        return parsed;
+    }
+    it("property: valid API response parses correctly", () => {
+        const apiResponse = JSON.stringify({
+            queries: ["database", "authentication", "user management"]
+        });
+        const result = parseRecentQueriesResponse(apiResponse);
+        expect(result.queries).toHaveLength(3);
+        expect(result.queries[0]).toBe("database");
+    });
+    it("property: empty queries array is valid", () => {
+        const apiResponse = JSON.stringify({ queries: [] });
+        const result = parseRecentQueriesResponse(apiResponse);
+        expect(result.queries).toHaveLength(0);
+    });
+    it("property: malformed response throws error", () => {
+        expect(() => parseRecentQueriesResponse("not json")).toThrow();
+        expect(() => parseRecentQueriesResponse("{}")).toThrow();
+        expect(() => parseRecentQueriesResponse('{"results": []}')).toThrow();
+    });
+});
+//# sourceMappingURL=dashboard.test.js.map

package/dist/mcp/client.test.js

@@ -0,0 +1,130 @@
+// Feature: memory-mcp-optimization, Property 16: MCPClient cleanup pending requests
+// Feature: memory-mcp-optimization, Property 17: MCPClient retry count
+import { describe, it, expect, vi } from "vitest";
+import * as fc from "fast-check";
+import { MCPClient } from "./client.js";
+class TestableMCPClient extends MCPClient {
+    get pending() {
+        return this.pendingRequests;
+    }
+    injectPending(n) {
+        const promises = [];
+        for (let i = 0; i < n; i++) {
+            const id = 1000 + i;
+            const p = new Promise((resolve, reject) => {
+                this.pending.set(id, {
+                    resolve,
+                    reject,
+                });
+            });
+            promises.push(p);
+        }
+        return promises;
+    }
+}
+describe("Property 16: MCPClient cleanup pending requests saat stop atau timeout", () => {
+    it("stop() clears the pending map synchronously", () => {
+        const client = new TestableMCPClient();
+        const n = 5;
+        const promises = client.injectPending(n);
+        const rejections = promises.map((p) => p.catch(() => undefined));
+        client.stop();
+        expect(client.getPendingCount()).toBe(0);
+        void Promise.all(rejections);
+    });
+    it("stop() rejects all pending requests with 'Client stopped'", async () => {
+        const client = new TestableMCPClient();
+        const n = 5;
+        const promises = client.injectPending(n);
+        client.stop();
+        const results = await Promise.allSettled(promises);
+        for (const result of results) {
+            expect(result.status).toBe("rejected");
+            if (result.status === "rejected") {
+                expect(result.reason.message).toBe("Client stopped");
+            }
+        }
+    });
+    it("getPendingCount() returns correct count before and after stop()", () => {
+        const client = new TestableMCPClient();
+        const n = 10;
+        const promises = client.injectPending(n);
+        const rejections = promises.map((p) => p.catch(() => undefined));
+        expect(client.getPendingCount()).toBe(n);
+        client.stop();
+        expect(client.getPendingCount()).toBe(0);
+        void Promise.all(rejections);
+    });
+    it("property: for any N >= 0, after stop() pendingCount === 0", () => {
+        fc.assert(fc.property(fc.integer({ min: 0, max: 20 }), (n) => {
+            const client = new TestableMCPClient();
+            const promises = client.injectPending(n);
+            promises.forEach((p) => p.catch(() => undefined));
+            client.stop();
+            return client.getPendingCount() === 0;
+        }));
+    });
+});
+describe("Property 17: MCPClient retry maksimal 3 kali dengan exponential backoff", () => {
+    it("retries exactly 3 times (4 total attempts) on timeout before rejecting", async () => {
+        vi.useFakeTimers();
+        try {
+            let callOnceCount = 0;
+            const client = new TestableMCPClient();
+            client.callOnce = async (_method, _params) => {
+                callOnceCount++;
+                throw new Error("Request timeout");
+            };
+            client.process = { stdin: { write: () => true } };
+            const retryPromise = client.callWithRetry("test/method", {});
+            retryPromise.catch(() => undefined);
+            await vi.runAllTimersAsync();
+            const result = await retryPromise.catch((e) => e);
+            expect(result).toBeInstanceOf(Error);
+            expect(result.message).toBe("Request timeout");
+            expect(callOnceCount).toBe(4);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("does not retry on non-timeout errors", async () => {
+        vi.useFakeTimers();
+        try {
+            let callOnceCount = 0;
+            const client = new TestableMCPClient();
+            client.callOnce = async (_method, _params) => {
+                callOnceCount++;
+                throw new Error("Some other error");
+            };
+            client.process = { stdin: { write: () => true } };
+            const retryPromise = client.callWithRetry("test/method", {});
+            retryPromise.catch(() => undefined);
+            await vi.runAllTimersAsync();
+            const result = await retryPromise.catch((e) => e);
+            expect(result).toBeInstanceOf(Error);
+            expect(result.message).toBe("Some other error");
+            expect(callOnceCount).toBe(1);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("property: retry delays follow exponential backoff pattern", () => {
+        vi.useFakeTimers();
+        try {
+            fc.assert(fc.property(fc.constant(null), () => {
+                const expectedDelays = [1000, 2000, 4000];
+                expect(expectedDelays).toHaveLength(3);
+                for (let i = 1; i < expectedDelays.length; i++) {
+                    expect(expectedDelays[i]).toBe(expectedDelays[i - 1] * 2);
+                }
+                return true;
+            }));
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});
+//# sourceMappingURL=client.test.js.map

package/dist/resources/index.test.js

@@ -0,0 +1,96 @@
+// Feature: memory-mcp-optimization, Property 19: memory://index filter repo
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { SQLiteStore } from "../storage/sqlite.js";
+import { readResource } from "./index.js";
+function makeEntry(id, repo) {
+    return {
+        id,
+        type: "code_fact",
+        title: `Memory ${id}`,
+        content: `Content for memory ${id} in repo ${repo}`,
+        importance: 3,
+        scope: { repo },
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        hit_count: 0,
+        recall_count: 0,
+        last_used_at: null,
+        expires_at: null,
+    };
+}
+describe("readResource memory://index", () => {
+    it("returns recent entries when no repo filter", () => {
+        const db = new SQLiteStore(":memory:");
+        db.insert(makeEntry("id-1", "repo-a"));
+        db.insert(makeEntry("id-2", "repo-b"));
+        const result = readResource("memory://index", db);
+        const entries = JSON.parse(result.contents[0].text);
+        expect(entries.length).toBeGreaterThan(0);
+        db.close();
+    });
+    it("returns only entries for the specified repo when ?repo=X is given", () => {
+        const db = new SQLiteStore(":memory:");
+        db.insert(makeEntry("id-a1", "repo-alpha"));
+        db.insert(makeEntry("id-a2", "repo-alpha"));
+        db.insert(makeEntry("id-b1", "repo-beta"));
+        const result = readResource("memory://index?repo=repo-alpha", db);
+        const entries = JSON.parse(result.contents[0].text);
+        expect(entries.length).toBeGreaterThan(0);
+        for (const entry of entries) {
+            expect(entry.scope.repo).toBe("repo-alpha");
+        }
+        db.close();
+    });
+    it("returns empty array when repo has no entries", () => {
+        const db = new SQLiteStore(":memory:");
+        db.insert(makeEntry("id-1", "repo-a"));
+        const result = readResource("memory://index?repo=nonexistent", db);
+        const entries = JSON.parse(result.contents[0].text);
+        expect(entries).toEqual([]);
+        db.close();
+    });
+    /**
+     * Property 19: memory://index dengan filter repo mengembalikan subset yang benar
+     * Validates: Requirements 19.1, 19.3
+     */
+    it("Property 19: all returned entries have repo === queried repo", () => {
+        fc.assert(fc.property(
+        // Generate 2-4 distinct repo names
+        fc.uniqueArray(fc.stringMatching(/^[a-z][a-z0-9-]{2,8}$/), { minLength: 2, maxLength: 4 }), 
+        // Generate 1-5 memories per repo
+        fc.integer({ min: 1, max: 5 }), (repos, memoriesPerRepo) => {
+            const db = new SQLiteStore(":memory:");
+            // Insert memories for each repo
+            let counter = 0;
+            for (const repo of repos) {
+                for (let i = 0; i < memoriesPerRepo; i++) {
+                    db.insert(makeEntry(`id-${counter++}`, repo));
+                }
+            }
+            // Query with the first repo as filter
+            const targetRepo = repos[0];
+            const result = readResource(`memory://index?repo=${targetRepo}`, db);
+            const entries = JSON.parse(result.contents[0].text);
+            // All returned entries must belong to targetRepo
+            const allMatch = entries.every((e) => e.scope.repo === targetRepo);
+            db.close();
+            return allMatch;
+        }), { numRuns: 100 });
+    });
+    it("Property 19 (no filter): returns entries from all repos", () => {
+        fc.assert(fc.property(fc.uniqueArray(fc.stringMatching(/^[a-z][a-z0-9-]{2,8}$/), { minLength: 2, maxLength: 3 }), (repos) => {
+            const db = new SQLiteStore(":memory:");
+            for (const repo of repos) {
+                db.insert(makeEntry(`id-${repo}`, repo));
+            }
+            const result = readResource("memory://index", db);
+            const entries = JSON.parse(result.contents[0].text);
+            // Without filter, should return entries (listRecent returns id/type/repo)
+            expect(entries.length).toBeGreaterThan(0);
+            db.close();
+            return true;
+        }), { numRuns: 100 });
+    });
+});
+//# sourceMappingURL=index.test.js.map