@vheins/local-memory-mcp 0.1.0 → 0.1.2

package/dist/tools/memory.search.test.js

@@ -1,181 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as fc from "fast-check";
-// ─── Property 2: Recap conditional ───────────────────────────────────────────
-// Feature: memory-mcp-optimization, Property 2: Recap conditional
-// We test the weight constants directly by importing them from the module.
-// For Property 2 we need to verify the conditional recap call logic.
-// We do this by extracting the logic into a testable helper and verifying
-// the branching behaviour with fast-check.
-/**
- * Mirrors the weight selection logic from memory.search.ts.
- * Returns the weights object that would be used given whether vector results
- * are present or not.
- */
-function selectWeights(vectorResultsEmpty) {
-    if (vectorResultsEmpty) {
-        return { similarity: 0.85, importance: 0.15 };
-    }
-    return { similarity: 0.6, vector: 0.3, importance: 0.1 };
-}
-/**
- * Mirrors the recap-call decision from memory.search.ts.
- * Returns true if handleMemoryRecap should be called.
- */
-function shouldCallRecap(includeRecap) {
-    return includeRecap === true;
-}
-// ─── Property 2 tests ────────────────────────────────────────────────────────
-describe("Property 2: Recap dipanggil jika dan hanya jika includeRecap = true", () => {
-    // Feature: memory-mcp-optimization, Property 2: Recap conditional
-    // Validates: Requirements 2.1, 2.2, 2.3
-    it("should NOT call recap when includeRecap is false or absent", () => {
-        fc.assert(fc.property(fc.oneof(fc.constant(false), fc.constant(undefined)), (includeRecap) => {
-            expect(shouldCallRecap(includeRecap)).toBe(false);
-        }), { numRuns: 100 });
-    });
-    it("should call recap when includeRecap is true", () => {
-        fc.assert(fc.property(fc.constant(true), (includeRecap) => {
-            expect(shouldCallRecap(includeRecap)).toBe(true);
-        }), { numRuns: 100 });
-    });
-    it("recap is called if and only if includeRecap === true (combined property)", () => {
-        fc.assert(fc.property(fc.oneof(fc.constant(true), fc.constant(false), fc.constant(undefined)), (includeRecap) => {
-            const called = shouldCallRecap(includeRecap);
-            // The iff condition: called ↔ (includeRecap === true)
-            expect(called).toBe(includeRecap === true);
-        }), { numRuns: 200 });
-    });
-});
-// ─── Property 3: Hybrid score weights sum to 1.0 ─────────────────────────────
-describe("Property 3: Total bobot Hybrid Score selalu = 1.0", () => {
-    // Feature: memory-mcp-optimization, Property 3: Hybrid score weights sum to 1.0
-    // Validates: Requirements 3.1, 3.2, 3.4
-    it("weights sum to 1.0 when vector store is empty (no vector results)", () => {
-        fc.assert(fc.property(fc.constant(true), // vectorResultsEmpty = true
-        (vectorResultsEmpty) => {
-            const weights = selectWeights(vectorResultsEmpty);
-            const sum = weights.similarity + (weights.vector ?? 0) + weights.importance;
-            expect(Math.abs(sum - 1.0)).toBeLessThan(1e-10);
-        }), { numRuns: 100 });
-    });
-    it("weights sum to 1.0 when vector store is active (has vector results)", () => {
-        fc.assert(fc.property(fc.constant(false), // vectorResultsEmpty = false
-        (vectorResultsEmpty) => {
-            const weights = selectWeights(vectorResultsEmpty);
-            const sum = weights.similarity + (weights.vector ?? 0) + weights.importance;
-            expect(Math.abs(sum - 1.0)).toBeLessThan(1e-10);
-        }), { numRuns: 100 });
-    });
-    it("weights always sum to 1.0 for both vector conditions", () => {
-        fc.assert(fc.property(fc.boolean(), // arbitrary vectorResultsEmpty flag
-        (vectorResultsEmpty) => {
-            const weights = selectWeights(vectorResultsEmpty);
-            const sum = weights.similarity + (weights.vector ?? 0) + weights.importance;
-            expect(Math.abs(sum - 1.0)).toBeLessThan(1e-10);
-        }), { numRuns: 200 });
-    });
-    it("vector-active weights are exactly 0.6 + 0.3 + 0.1 = 1.0", () => {
-        const weights = selectWeights(false);
-        expect(weights.similarity).toBe(0.6);
-        expect(weights.vector).toBe(0.3);
-        expect(weights.importance).toBe(0.1);
-        expect(weights.similarity + (weights.vector ?? 0) + weights.importance).toBeCloseTo(1.0, 10);
-    });
-    it("vector-empty weights are exactly 0.85 + 0.15 = 1.0", () => {
-        const weights = selectWeights(true);
-        expect(weights.similarity).toBe(0.85);
-        expect(weights.vector).toBeUndefined();
-        expect(weights.importance).toBe(0.15);
-        expect(weights.similarity + weights.importance).toBe(1.0);
-    });
-});
-// ─── Prompt parameter tests ─────────────────────────────────────────────────
-describe("Property: prompt parameter in memory-search", () => {
-    it("prompt is optional - search works without prompt", () => {
-        const params = {
-            query: "database orm",
-            repo: "test-repo",
-            limit: 5
-        };
-        // If prompt is not provided, searchQuery should equal query
-        const hasPrompt = 'prompt' in params && params.prompt;
-        const searchQuery = hasPrompt
-            ? `${params.query} ${params.prompt}`
-            : params.query;
-        expect(searchQuery).toBe("database orm");
-    });
-    it("prompt is combined with query when provided", () => {
-        const params = {
-            query: "database orm",
-            prompt: "I need user authentication",
-            repo: "test-repo",
-            limit: 5
-        };
-        const searchQuery = params.prompt
-            ? `${params.query} ${params.prompt}`
-            : params.query;
-        expect(searchQuery).toBe("database orm I need user authentication");
-    });
-    it("prompt can be empty string - treated as no prompt (empty string is falsy)", () => {
-        const params = {
-            query: "database orm",
-            prompt: "",
-            repo: "test-repo",
-            limit: 5
-        };
-        // Empty string is falsy in JS, so it uses just query
-        const searchQuery = params.prompt
-            ? `${params.query} ${params.prompt}`
-            : params.query;
-        expect(searchQuery).toBe("database orm");
-    });
-    it("matchReason includes prompt when provided", () => {
-        const query = "database orm";
-        const prompt = "user authentication context";
-        const matchReason = prompt
-            ? `Results ranked by relevance to "${query}" with context: ${prompt}`
-            : `Results ranked by relevance to "${query}"`;
-        expect(matchReason).toContain("database orm");
-        expect(matchReason).toContain("user authentication context");
-        expect(matchReason).toContain("with context:");
-    });
-    it("matchReason does not include prompt when not provided", () => {
-        const query = "database orm";
-        const prompt = undefined;
-        const matchReason = prompt
-            ? `Results ranked by relevance to "${query}" with context: ${prompt}`
-            : `Results ranked by relevance to "${query}"`;
-        expect(matchReason).toBe(`Results ranked by relevance to "${query}"`);
-        expect(matchReason).not.toContain("with context:");
-    });
-    it("property: searchQuery combines query and prompt consistently", () => {
-        fc.assert(fc.property(fc.string({ minLength: 3, maxLength: 50 }), fc.string({ minLength: 1, maxLength: 100 }), (query, prompt) => {
-            const searchQuery = `${query} ${prompt}`;
-            // Search query should always start with the original query
-            expect(searchQuery.startsWith(query)).toBe(true);
-            // Search query should contain the prompt
-            expect(searchQuery.includes(prompt)).toBe(true);
-            // There should be exactly one space between query and prompt
-            expect(searchQuery).toBe(`${query} ${prompt}`);
-        }), { numRuns: 50 });
-    });
-    it("property: matchReason format is correct with and without prompt", () => {
-        fc.assert(fc.property(fc.string({ minLength: 1, maxLength: 30 }), fc.option(fc.string({ minLength: 1, maxLength: 50 })), (query, prompt) => {
-            const matchReason = prompt
-                ? `Results ranked by relevance to "${query}" with context: ${prompt}`
-                : `Results ranked by relevance to "${query}"`;
-            // Should always contain the query
-            expect(matchReason).toContain(query);
-            if (prompt) {
-                // Should contain "with context:" when prompt exists
-                expect(matchReason).toContain("with context:");
-                expect(matchReason).toContain(prompt);
-            }
-            else {
-                // Should NOT contain "with context:" when prompt is absent
-                expect(matchReason).not.toContain("with context:");
-            }
-        }), { numRuns: 50 });
-    });
-});
-//# sourceMappingURL=memory.search.test.js.map

package/dist/utils/logger.test.js

@@ -1,84 +0,0 @@
-// 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

@@ -1,159 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-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/docs/PRD.md

@@ -1,199 +0,0 @@
-# PRD – MCP Local Memory Service
-
-## TL;DR
-
-Membangun **MCP Local Memory Service** berbasis Node.js yang menyediakan *long-term, high-signal memory* untuk coding copilot & antigravity agent. Sistem ini menyimpan keputusan, fakta kode, kesalahan, dan pola penting menggunakan SQLite + vector similarity search, sehingga agent tetap konsisten, tidak mengulang kesalahan, dan tahan terhadap typo / variasi query.
-
----
-
-## Problem Statement
-
-Coding copilot dan agent saat ini:
-- Mudah kehilangan konteks keputusan sebelumnya
-- Mengulang kesalahan yang sama
-- Overfit ke prompt terakhir (*gravity problem*)
-- Lemah terhadap typo atau phrasing berbeda
-
-Tanpa memory terstruktur, agent terasa "pintar sesaat" tapi tidak reliable untuk penggunaan jangka panjang.
-
----
-
-## Goals
-
-### Business Goals
-- Meningkatkan kualitas dan konsistensi output coding copilot
-- Mengurangi user correction berulang
-- Menjadikan agent usable untuk long-running projects
-
-### User Goals
-- Agent mengingat keputusan & constraint penting
-- Agent tidak mengulang kesalahan lama
-- Agent tetap relevan walau prompt berubah atau typo
-
-### Non-Goals
-- Bukan chat history logger
-- Bukan audit trail
-- Tidak mendukung distributed / cloud sync (local-first)
-
----
-
-## Target Users
-- Developer menggunakan coding copilot lokal
-- Power user / engineer yang menginginkan agent “punya ingatan”
-- Pengguna MCP-based agent system
-
----
-
-## User Stories
-1. **Sebagai developer**, saya ingin agent mengingat keputusan arsitektur agar tidak perlu menjelaskannya berulang kali.
-2. **Sebagai developer**, saya ingin agent tidak mengulang kesalahan yang sudah saya koreksi sebelumnya.
-3. **Sebagai developer**, saya ingin agent tetap menemukan memory relevan walau saya salah ketik atau pakai istilah berbeda.
-4. **Sebagai agent**, saya ingin memory yang ringkas dan relevan agar tidak membanjiri prompt.
-
----
-
-## Memory Types (Core Concept)
-
-### 1. code_fact
-Fakta stabil tentang codebase.
-*Contoh:*
-- Project pakai clean architecture
-- Semua API pakai zod validation
-
-### 2. decision
-Keputusan desain atau arsitektur.
-*Contoh:*
-- Tidak menggunakan ORM
-- Menggunakan raw SQL demi performa
-
-### 3. mistake
-Kesalahan yang tidak boleh diulang.
-*Contoh:*
-- Jangan pakai default export
-- Jangan gunakan `any` di domain layer
-
-### 4. pattern
-Pola kode atau konvensi yang sering dipakai.
-*Contoh:*
-- Struktur handler
-- Pola error handling
-
----
-
-## User Experience (End-to-End Flow)
-
-### 1. Normal Interaction
-1. User meminta agent generate / modify code
-2. Agent membaca project summary (jika ada)
-3. Agent mencari memory relevan via semantic search
-4. Memory terpilih diinjeksi ke prompt
-5. Agent menghasilkan code sesuai constraint
-
-### 2. Memory Creation Flow
-1. User memberi constraint / koreksi penting
-2. Agent mendeteksi sinyal *memory-worthy*
-3. Agent menyimpan memory via MCP tool
-4. Agent (opsional) update project summary
-
----
-
-## Narrative (Executive Story)
-
-Bayangkan seorang developer bekerja di codebase selama berminggu-minggu. Ia sudah menetapkan aturan: arsitektur tertentu, larangan tertentu, dan pola kode yang disepakati.
-
-Tanpa memory, setiap hari agent kembali seperti "intern baru" — pintar, tapi lupa segalanya.
-
-Dengan **MCP Local Memory Service**, agent berubah menjadi rekan tim yang belajar:
-- Mengingat keputusan
-- Menghindari kesalahan lama
-- Berpikir di level arsitektur
-
-Ini bukan soal membuat agent lebih pintar — tapi membuatnya lebih dapat dipercaya.
-
----
-
-## Functional Requirements
-
-### Memory Storage
-- Menyimpan memory bertipe: `code_fact`, `decision`, `mistake`, `pattern`
-- Mendukung metadata scope (repo, language, folder)
-- Mendukung importance score (1–5)
-
-### Memory Retrieval
-- Semantic similarity search (vector-based)
-- Tahan typo & variasi bahasa
-- Mendukung filtering by type, scope, importance
-
-### Memory Summary
-- Ringkasan high-level per repo
-- Digunakan sebagai *antigravity anchor*
-
----
-
-## MCP Interface
-
-### Resources
-- `memory://entries`
-- `memory://summary`
-
-### Tools
-- `memory.search`
-- `memory.store`
-- `memory.summarize`
-
-Agent tidak mengetahui detail database atau vector engine.
-
----
-
-## Success Metrics
-
-### Quantitative
-- Penurunan jumlah user correction berulang
-- Peningkatan reuse memory dalam prompt
-- Latency memory search < 100ms (local)
-
-### Qualitative
-- Agent terasa konsisten
-- Agent tidak mengulang kesalahan lama
-- User trust meningkat
-
----
-
-## Technical Considerations
-- Node.js MCP server
-- SQLite sebagai primary storage
-- Vector similarity via sqlite extension atau embedded index
-- Local embedding model (via Ollama / llama.cpp)
-- Normalization layer untuk typo handling
-
----
-
-## Milestones & Sequencing
-1. MCP contract & interface definition (XX weeks)
-2. SQLite schema + vector indexing (XX weeks)
-3. Memory search & ranking logic (XX weeks)
-4. Agent prompt integration (XX weeks)
-5. Heuristic-based auto memory rules (XX weeks)
-
----
-
-## Risks & Mitigations
-- **Risk: Memory pollution**
-  - *Mitigasi:* strict store rules + importance threshold
-- **Risk: Prompt bloat**
-  - *Mitigasi:* limit memory injection + summary usage
-- **Risk: Overfitting memory**
-  - *Mitigasi:* relevance threshold + scope filtering
-
----
-
-## Open Questions
-- Perlu manual memory deletion UI?
-- Perlu memory versioning?
-- Perlu cross-repo inference di masa depan?
-
----
-
-## Final Take
-Produk ini bukan tentang database atau vector search.
-Ini tentang mendisiplinkan ingatan agent agar ia benar-benar berguna untuk kerja nyata.