@vheins/local-memory-mcp 0.1.4 → 0.1.5

package/dist/utils/logger.test.js

@@ -0,0 +1,84 @@
+// Feature: memory-mcp-optimization
+// Property 20: StructuredLogger output adalah JSON valid dengan field wajib
+// Validates: Requirements 21.1, 21.2
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fc from "fast-check";
+describe("Property 20: StructuredLogger output adalah JSON valid dengan field wajib", () => {
+    let stderrOutput = [];
+    let stderrSpy;
+    beforeEach(() => {
+        stderrOutput = [];
+        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation((chunk) => {
+            stderrOutput.push(typeof chunk === "string" ? chunk : chunk.toString());
+            return true;
+        });
+        // Reset LOG_LEVEL to ensure all levels are logged
+        process.env.LOG_LEVEL = "debug";
+    });
+    afterEach(() => {
+        stderrSpy.mockRestore();
+        delete process.env.LOG_LEVEL;
+    });
+    it("each log call produces valid JSON output with required fields", async () => {
+        // Re-import logger after setting LOG_LEVEL
+        const { logger } = await import("./logger.js?t=" + Date.now());
+        fc.assert(fc.property(fc.oneof(fc.constant("debug"), fc.constant("info"), fc.constant("warn"), fc.constant("error")), fc.string({ minLength: 1, maxLength: 100 }), (level, message) => {
+            stderrOutput = [];
+            logger[level](message);
+            expect(stderrOutput.length).toBeGreaterThanOrEqual(1);
+            const lastOutput = stderrOutput[stderrOutput.length - 1];
+            // Must be parseable JSON
+            let parsed;
+            expect(() => {
+                parsed = JSON.parse(lastOutput.trim());
+            }).not.toThrow();
+            parsed = JSON.parse(lastOutput.trim());
+            // Must have required fields
+            expect(parsed).toHaveProperty("level");
+            expect(parsed).toHaveProperty("timestamp");
+            expect(parsed).toHaveProperty("message");
+            // level must match
+            expect(parsed.level).toBe(level);
+            // message must match
+            expect(parsed.message).toBe(message);
+            // timestamp must be ISO 8601
+            expect(typeof parsed.timestamp).toBe("string");
+            const ts = new Date(parsed.timestamp);
+            expect(isNaN(ts.getTime())).toBe(false);
+        }), { numRuns: 100 });
+    });
+    it("log output with context includes context field", async () => {
+        const { logger } = await import("./logger.js?t=" + Date.now() + "ctx");
+        stderrOutput = [];
+        logger.info("test message", { key: "value", count: 42 });
+        expect(stderrOutput.length).toBeGreaterThanOrEqual(1);
+        const lastOutput = stderrOutput[stderrOutput.length - 1];
+        const parsed = JSON.parse(lastOutput.trim());
+        expect(parsed).toHaveProperty("context");
+        expect(parsed.context).toEqual({ key: "value", count: 42 });
+    });
+    it("log output without context does not include context field", async () => {
+        const { logger } = await import("./logger.js?t=" + Date.now() + "noctx");
+        stderrOutput = [];
+        logger.info("no context message");
+        expect(stderrOutput.length).toBeGreaterThanOrEqual(1);
+        const lastOutput = stderrOutput[stderrOutput.length - 1];
+        const parsed = JSON.parse(lastOutput.trim());
+        expect(parsed).not.toHaveProperty("context");
+    });
+    it("all four log levels produce valid JSON with correct level field", async () => {
+        const { logger } = await import("./logger.js?t=" + Date.now() + "levels");
+        const levels = ["debug", "info", "warn", "error"];
+        for (const level of levels) {
+            stderrOutput = [];
+            logger[level](`test ${level} message`);
+            expect(stderrOutput.length).toBeGreaterThanOrEqual(1);
+            const lastOutput = stderrOutput[stderrOutput.length - 1];
+            const parsed = JSON.parse(lastOutput.trim());
+            expect(parsed.level).toBe(level);
+            expect(parsed.message).toBe(`test ${level} message`);
+            expect(typeof parsed.timestamp).toBe("string");
+        }
+    });
+});
+//# sourceMappingURL=logger.test.js.map

package/dist/utils/normalize.test.js

@@ -0,0 +1,159 @@
+// Feature: memory-mcp-optimization
+// Unit + Property tests for normalize(), tokenize(), and STOPWORDS
+// Requirements: 5.4, 5.5, 17.3, 17.4, 17.7
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { normalize, tokenize, STOPWORDS } from "./normalize.js";
+// ─── Unit Tests: normalize() ─────────────────────────────────────────────────
+describe("normalize() — unit tests", () => {
+    it("converts text to lowercase", () => {
+        expect(normalize("Hello World")).toBe("hello world");
+        expect(normalize("TYPESCRIPT")).toBe("typescript");
+        expect(normalize("CamelCase")).toBe("camelcase");
+    });
+    it("trims leading and trailing whitespace", () => {
+        expect(normalize("  hello  ")).toBe("hello");
+        expect(normalize("\t  text  \n")).toBe("text");
+    });
+    it("replaces special characters with spaces", () => {
+        const result = normalize("hello!world@test#value");
+        // Special chars replaced by spaces, then collapsed
+        expect(result).not.toContain("!");
+        expect(result).not.toContain("@");
+        expect(result).not.toContain("#");
+    });
+    it("collapses multiple spaces into one", () => {
+        expect(normalize("hello   world")).toBe("hello world");
+        expect(normalize("a  b  c")).toBe("a b c");
+    });
+    it("handles empty string", () => {
+        expect(normalize("")).toBe("");
+    });
+    it("handles string with only special characters", () => {
+        expect(normalize("!!!@@@###")).toBe("");
+    });
+    it("preserves alphanumeric characters", () => {
+        expect(normalize("abc123")).toBe("abc123");
+    });
+});
+// ─── Unit Tests: tokenize() ──────────────────────────────────────────────────
+describe("tokenize() — unit tests", () => {
+    it("removes stopwords from output", () => {
+        const tokens = tokenize("the quick brown fox");
+        expect(tokens).not.toContain("the");
+        expect(tokens).toContain("quick");
+        expect(tokens).toContain("brown");
+        expect(tokens).toContain("fox");
+    });
+    it("removes short words (length <= 0 after normalize)", () => {
+        // tokenize filters tokens with length > 0 and not in STOPWORDS
+        const tokens = tokenize("a b c hello");
+        // "a", "b", "c" are stopwords or single chars
+        expect(tokens).toContain("hello");
+    });
+    it("returns empty array for all-stopword input", () => {
+        const tokens = tokenize("the and or but");
+        expect(tokens).toEqual([]);
+    });
+    it("handles empty string", () => {
+        expect(tokenize("")).toEqual([]);
+    });
+    it("normalizes before tokenizing (lowercase, trim)", () => {
+        const tokens1 = tokenize("TypeScript");
+        const tokens2 = tokenize("typescript");
+        expect(tokens1).toEqual(tokens2);
+    });
+    it("removes Indonesian stopwords", () => {
+        const tokens = tokenize("yang dan di ke dari ini itu coding");
+        expect(tokens).not.toContain("yang");
+        expect(tokens).not.toContain("dan");
+        expect(tokens).toContain("coding");
+    });
+});
+// ─── Property 4: Tokenisasi konsisten antara SQLiteStore dan StubVectorStore ──
+// Feature: memory-mcp-optimization, Property 4: Tokenisasi konsisten
+// Validates: Requirements 4.4, 5.2, 5.3
+describe("Property 4: Tokenisasi konsisten antara SQLiteStore dan StubVectorStore", () => {
+    it("tokenize() is deterministic — same input always produces same output", () => {
+        fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 100 }), (text) => {
+            // Both SQLiteStore and StubVectorStore use tokenize() from normalize.ts
+            // So testing tokenize() determinism validates consistency between them
+            const result1 = tokenize(text);
+            const result2 = tokenize(text);
+            expect(result1).toEqual(result2);
+        }), { numRuns: 200 });
+    });
+    it("tokenize() output is a subset of normalize() tokens", () => {
+        fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 100 }), (text) => {
+            const normalized = normalize(text);
+            const allTokens = normalized.split(" ").filter((t) => t.length > 0);
+            const filtered = tokenize(text);
+            // Every token in filtered must appear in allTokens
+            for (const token of filtered) {
+                expect(allTokens).toContain(token);
+            }
+        }), { numRuns: 200 });
+    });
+});
+// ─── Property 5: normalize() idempoten ganda ─────────────────────────────────
+// Feature: memory-mcp-optimization, Property 5: normalize() idempoten ganda
+// Validates: Requirements 5.4, 5.5
+describe("Property 5: normalize() idempoten ganda", () => {
+    it("normalize(normalize(text)) === normalize(text) for 100+ random inputs", () => {
+        fc.assert(fc.property(fc.string({ minLength: 0, maxLength: 200 }), (text) => {
+            const once = normalize(text);
+            const twice = normalize(once);
+            expect(twice).toBe(once);
+        }), { numRuns: 200 });
+    });
+    it("normalize is idempotent for specific edge cases", () => {
+        const cases = [
+            "",
+            "   ",
+            "Hello World!",
+            "UPPERCASE",
+            "already normalized",
+            "multiple   spaces",
+            "special!@#chars",
+            "123numbers456",
+        ];
+        for (const text of cases) {
+            const once = normalize(text);
+            const twice = normalize(once);
+            expect(twice).toBe(once);
+        }
+    });
+});
+// ─── Property 21: Stopword list tidak mengandung duplikat ────────────────────
+// Feature: memory-mcp-optimization, Property 21: Stopword no duplicates
+// Validates: Requirement 17.4
+describe("Property 21: Stopword list tidak mengandung duplikat", () => {
+    it("STOPWORDS has no duplicate entries", () => {
+        // Since STOPWORDS is a Set, duplicates are automatically removed.
+        // We verify the source array (before Set construction) has no duplicates
+        // by checking that Set size equals the number of unique entries.
+        // The Set itself guarantees uniqueness, so we verify the exported Set is consistent.
+        const stopwordsArray = Array.from(STOPWORDS);
+        const uniqueSet = new Set(stopwordsArray);
+        expect(uniqueSet.size).toBe(stopwordsArray.length);
+    });
+    it("all STOPWORDS entries are lowercase strings", () => {
+        for (const word of STOPWORDS) {
+            expect(typeof word).toBe("string");
+            expect(word).toBe(word.toLowerCase());
+        }
+    });
+    it("STOPWORDS is non-empty", () => {
+        expect(STOPWORDS.size).toBeGreaterThan(0);
+    });
+    it("property: no string appears more than once in STOPWORDS", () => {
+        // This is a structural property — verified once (not random inputs needed)
+        // since STOPWORDS is a constant Set
+        const seen = new Set();
+        for (const word of STOPWORDS) {
+            expect(seen.has(word)).toBe(false);
+            seen.add(word);
+        }
+    });
+});
+//# sourceMappingURL=normalize.test.js.map

package/dist/utils/query-expander.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { expandQuery } from "../utils/query-expander.js";
+describe("expandQuery", () => {
+    it("returns original query when no prompt provided", () => {
+        expect(expandQuery("database")).toBe("database");
+        expect(expandQuery("api endpoint")).toBe("api endpoint");
+    });
+    it("expands query with prompt keywords", () => {
+        const result = expandQuery("database", "user authentication implementation");
+        expect(result).toContain("database");
+        expect(result).toContain("user");
+        expect(result).toContain("auth");
+    });
+    it("expands known keywords", () => {
+        const result = expandQuery("auth", "login system");
+        expect(result).toContain("auth");
+        expect(result).toContain("login");
+        expect(result).toContain("password");
+    });
+    it("limits to 10 keywords", () => {
+        const result = expandQuery("api", "building a rest endpoint with controller and route handling");
+        const words = result.split(" ");
+        expect(words.length).toBeLessThanOrEqual(10);
+    });
+    it("removes duplicates", () => {
+        const result = expandQuery("database", "database query optimization");
+        const words = result.split(" ");
+        const unique = new Set(words);
+        expect(words.length).toBe(unique.size);
+    });
+    it("handles empty prompt gracefully", () => {
+        expect(expandQuery("test", "")).toBe("test");
+    });
+});
+//# sourceMappingURL=query-expander.test.js.map

package/package.json

@@ -1,17 +1,22 @@
 {
 	"name": "@vheins/local-memory-mcp",
-	"version": "0.1.4",
+	"version": "0.1.5",
 	"description": "MCP Local Memory Service for coding copilot agents",
+	"mcpName": "io.github.vheins/local-memory-mcp",
 	"type": "module",
 	"main": "dist/server.js",
 	"bin": {
 		"local-memory-mcp": "dist/server.js",
 		"mcp-memory-dashboard": "dist/dashboard/server.js"
 	},
+	"files": [
+		"dist"
+	],
 	"author": "Muhammad Rheza Alfin <m.rheza.alfin@gmail.com>",
 	"license": "MIT",
 	"scripts": {
-		"build": "tsc && mkdir -p dist/dashboard/public && rsync -a --delete src/dashboard/public/ dist/dashboard/public/",
+		"build": "tsc && mkdir -p dist/dashboard/public && rsync -a --delete src/dashboard/public/ dist/dashboard/public/ && shx chmod +x dist/server.js dist/dashboard/server.js",
+		"prepare": "npm run build",
 		"dev": "tsc --watch",
 		"start": "node dist/server.js",
 		"dashboard": "node dist/dashboard/server.js",
@@ -31,6 +36,7 @@
 		"@types/express": "^5.0.6",
 		"@types/node": "^22.19.7",
 		"fast-check": "^4.6.0",
+		"shx": "^0.4.0",
 		"typescript": "^5.7.3",
 		"vitest": "^4.1.1"
 	}

package/.kiro/specs/memory-mcp-optimization/.config.kiro

@@ -1 +0,0 @@
-{"specId": "a9aa2a01-bac5-484c-8b95-7f5536bca00e", "workflowType": "requirements-first", "specType": "feature"}

package/.vscode/tasks.json

@@ -1,27 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "Start Dashboard",
-      "type": "shell",
-      "command": "npm",
-      "args": ["run", "dashboard"],
-      "options": {
-        "cwd": "/home/vheins/Projects/local-memory-mcp"
-      },
-      "group": "build",
-      "presentation": {
-        "echo": true,
-        "reveal": "silent",
-        "focus": false,
-        "panel": "shared",
-        "showReuseMessage": true,
-        "clear": false
-      },
-      "isBackground": true,
-      "runOptions": {
-        "runOn": "folderOpen"
-      }
-    }
-  ]
-}