th-memory-mcp 1.1.0

package/dist/lib/distill-core.js

@@ -0,0 +1,137 @@
+// distill-core: pure rule-based summarization helpers for the Learning Loop.
+// NO DB imports — must compile with the main tsc config and stay testable.
+// --- stopwords (basic EN + TH) ---
+export const STOPWORDS = new Set([
+    // english
+    "the", "a", "an", "is", "are", "to", "of", "and", "or", "in", "on", "for",
+    "with", "this", "that", "it", "i", "you", "me", "my", "we", "be", "was",
+    "were", "been", "am", "do", "does", "did", "have", "has", "had", "not",
+    "no", "but", "so", "if", "then", "than", "as", "at", "by", "from", "into",
+    "about", "can", "could", "will", "would", "should", "shall", "may",
+    "might", "must", "just", "very", "there", "here", "what", "when", "where",
+    "which", "who", "how", "why", "all", "any", "some", "such", "own", "same",
+    "too", "its", "our", "your", "they", "them", "their", "he", "she", "his",
+    "her", "him", "us", "s", "t",
+    // thai
+    "และ", "หรือ", "ที่", "ให้", "ของ", "การ", "ไม่", "ใน", "มี", "ผม", "ฉัน",
+    "คือ", "ไป", "มา", "แล้ว", "ด้วย", "อะไร", "ทำ", "ใส่", "เป็น", "อยู่",
+    "จาก", "กับ", "ว่า", "นี้", "นั้น", "โดย", "ครับ", "ค่ะ", "ต้อง", "ยัง",
+    "เพื่อ", "แบบ", "หน่อย", "นะ", "ล่ะ", "เลย", "ก็", "แต่", "ถ้า", "ช่วย",
+]);
+let cachedSegmenter;
+function getSegmenter() {
+    if (cachedSegmenter !== undefined)
+        return cachedSegmenter;
+    try {
+        const intl = Intl;
+        if (typeof intl.Segmenter === "function") {
+            const segmenter = new intl.Segmenter("th", { granularity: "word" });
+            cachedSegmenter = (text) => {
+                const out = [];
+                for (const s of segmenter.segment(text)) {
+                    if (typeof s.segment === "string")
+                        out.push(s.segment);
+                }
+                return out;
+            };
+        }
+        else {
+            cachedSegmenter = null;
+        }
+    }
+    catch {
+        cachedSegmenter = null;
+    }
+    return cachedSegmenter;
+}
+const PURE_DIGITS = /^\d+$/;
+export function tokenize(text) {
+    const input = String(text ?? "");
+    const seg = getSegmenter();
+    const raw = seg ? seg(input) : input.split(/\s+/);
+    const out = [];
+    for (const r of raw) {
+        const tok = r.toLowerCase().trim();
+        if (tok.length < 2)
+            continue;
+        if (PURE_DIGITS.test(tok))
+            continue;
+        if (STOPWORDS.has(tok))
+            continue;
+        out.push(tok);
+    }
+    return out;
+}
+function topN(map, n) {
+    return [...map.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .slice(0, n);
+}
+function parseMetaObject(meta) {
+    if (typeof meta !== "string" || !meta.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(meta);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch { }
+    return null;
+}
+function bump(map, key) {
+    map.set(key, (map.get(key) ?? 0) + 1);
+}
+export function computeStats(rows) {
+    let totalPrompts = 0;
+    const days = new Set();
+    const toolCounts = new Map();
+    const keywordCounts = new Map();
+    const dirCounts = new Map();
+    for (const row of rows ?? []) {
+        if (!row || typeof row !== "object")
+            continue;
+        if (row.kind === "prompt") {
+            totalPrompts += 1;
+            days.add(String(row.ts ?? "").slice(0, 10));
+            for (const tok of tokenize(String(row.content ?? ""))) {
+                bump(keywordCounts, tok);
+            }
+        }
+        const metaObj = parseMetaObject(row.meta);
+        if (metaObj) {
+            const tool = metaObj.tool;
+            if (typeof tool === "string" && tool.trim()) {
+                bump(toolCounts, tool.trim());
+            }
+            const directory = metaObj.directory;
+            if (typeof directory === "string" && directory.trim()) {
+                bump(dirCounts, directory.trim());
+            }
+        }
+    }
+    return {
+        totalPrompts,
+        promptDays: days.size,
+        topTools: topN(toolCounts, 10),
+        topKeywords: topN(keywordCounts, 15),
+        topDirs: topN(dirCounts, 5),
+    };
+}
+function pairList(pairs) {
+    return pairs.map(([name, count]) => `${name}(${count})`).join(", ");
+}
+export function formatProfileSections(stats) {
+    const lines = [];
+    lines.push(`prompts: ${stats.totalPrompts} across ${stats.promptDays} ${stats.promptDays === 1 ? "day" : "days"}`);
+    if (stats.topTools.length > 0) {
+        lines.push(`top tools: ${pairList(stats.topTools)}`);
+    }
+    if (stats.topDirs.length > 0) {
+        lines.push(`top dirs: ${pairList(stats.topDirs)}`);
+    }
+    const topics = stats.topKeywords.length > 0
+        ? `frequent topics: ${stats.topKeywords.map(([w]) => w).join(", ")}`
+        : "frequent topics: (none)";
+    return { usage_stats: lines.join("\n"), topics };
+}

package/dist/tools/export_memory.js

@@ -0,0 +1,90 @@
+import { mkdirSync, writeFileSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { z } from "zod";
+import { db, DB_PATH, nowISO, truncate, ok, err, } from "../db.js";
+import { VERSION, EXPORTS_DIRNAME } from "../lib/config.js";
+export const exportMemoryInput = {
+    includeInteractions: z
+        .boolean()
+        .default(false)
+        .describe("Include raw interaction rows in the export (file gets bigger)"),
+    filename: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("Output file name inside data/exports/ (only A-Z a-z 0-9 . _ - allowed, must end with .json). Defaults to memory-export-YYYYMMDD-HHmmss.json"),
+};
+const PREVIEW_BUDGET = 500;
+const EXPORT_DIR = join(dirname(DB_PATH), EXPORTS_DIRNAME);
+const selectPrefs = db.prepare("SELECT id, category, key, value, confidence, source, updated_at FROM preferences ORDER BY id");
+const selectLessons = db.prepare("SELECT id, situation, mistake, correction, created_at FROM lessons ORDER BY id");
+const selectProfile = db.prepare("SELECT section, content, updated_at FROM profile ORDER BY section");
+const selectInteractions = db.prepare("SELECT id, ts, session_id, kind, content, meta FROM interactions ORDER BY id");
+function timestamp(d = new Date()) {
+    const p = (n) => String(n).padStart(2, "0");
+    return (`${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}` +
+        `-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`);
+}
+const WINDOWS_RESERVED = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    ...Array.from({ length: 9 }, (_, i) => `COM${i + 1}`),
+    ...Array.from({ length: 9 }, (_, i) => `LPT${i + 1}`),
+]);
+function sanitizeFilename(name) {
+    if (name.includes(".."))
+        return null;
+    if (!/^[A-Za-z0-9._-]+$/.test(name))
+        return null;
+    if (!name.endsWith(".json"))
+        return null;
+    const stem = name.slice(0, -".json".length);
+    if (stem.length === 0)
+        return null;
+    if (WINDOWS_RESERVED.has(stem.toUpperCase()))
+        return null;
+    return name;
+}
+export async function exportMemoryHandler(args) {
+    try {
+        const includeInteractions = args.includeInteractions ?? false;
+        let filename;
+        if (args.filename !== undefined) {
+            const clean = sanitizeFilename(args.filename);
+            if (!clean) {
+                return err(`invalid filename "${truncate(args.filename, 100)}": only [A-Za-z0-9._-] allowed, no "..", must end with .json`);
+            }
+            filename = clean;
+        }
+        else {
+            filename = `memory-export-${timestamp()}.json`;
+        }
+        const interactionsIncluded = includeInteractions
+            ? selectInteractions.all()
+            : undefined;
+        const payload = {
+            exported_at: nowISO(),
+            version: VERSION,
+            preferences: selectPrefs.all(),
+            lessons: selectLessons.all(),
+            profile: selectProfile.all(),
+            interactions: {
+                included: includeInteractions,
+                count: interactionsIncluded ? interactionsIncluded.length : 0,
+                ...(interactionsIncluded ? { rows: interactionsIncluded } : {}),
+            },
+        };
+        const json = JSON.stringify(payload, null, 2);
+        mkdirSync(EXPORT_DIR, { recursive: true });
+        const filePath = join(EXPORT_DIR, filename);
+        writeFileSync(filePath, json, "utf8");
+        const size = statSync(filePath).size;
+        return ok(`exported: ${filePath}\nsize: ${size} bytes\npreview: ${truncate(json, PREVIEW_BUDGET)}`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/forget.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { db, removeSearchIndex, ok, err } from "../db.js";
+export const forgetInput = {
+    target_id: z
+        .number()
+        .int()
+        .positive()
+        .describe("Row id to delete (id returned by remember/save_lesson)"),
+    type: z
+        .enum(["preference", "lesson", "interaction"])
+        .optional()
+        .describe("Which table the id belongs to. Recommended whenever known, because numeric ids can coincide across tables."),
+};
+const indexTables = db.prepare("SELECT DISTINCT ref_table FROM search_index WHERE ref_id = ?");
+const existsPreference = db.prepare("SELECT id FROM preferences WHERE id = ?");
+const existsLesson = db.prepare("SELECT id FROM lessons WHERE id = ?");
+const existsInteraction = db.prepare("SELECT id FROM interactions WHERE id = ?");
+const delPreference = db.prepare("DELETE FROM preferences WHERE id = ?");
+const delLesson = db.prepare("DELETE FROM lessons WHERE id = ?");
+const delInteraction = db.prepare("DELETE FROM interactions WHERE id = ?");
+function existsIn(kind, id) {
+    if (kind === "preferences") {
+        return !!existsPreference.get(id);
+    }
+    if (kind === "lessons") {
+        return !!existsLesson.get(id);
+    }
+    return !!existsInteraction.get(id);
+}
+export async function forgetHandler(args) {
+    try {
+        const id = args.target_id;
+        const kindOf = {
+            preference: "preferences",
+            lesson: "lessons",
+            interaction: "interactions",
+        };
+        let targets = [];
+        const typedKind = args.type ? kindOf[args.type] : undefined;
+        if (typedKind) {
+            targets = [typedKind];
+        }
+        else {
+            const indexed = indexTables.all(id);
+            const evidence = indexed
+                .map((r) => r.ref_table)
+                .filter((t) => t === "preferences" || t === "lessons" || t === "interactions");
+            const candidates = evidence.length > 0
+                ? evidence
+                : ["preferences", "lessons", "interactions"];
+            targets = candidates.filter((k) => existsIn(k, id));
+        }
+        if (targets.length === 0) {
+            return ok(`nothing found with id=${id}`);
+        }
+        const removed = [];
+        db.transaction(() => {
+            for (const kind of targets) {
+                if (!existsIn(kind, id))
+                    continue;
+                if (kind === "preferences") {
+                    delPreference.run(id);
+                    removeSearchIndex("preferences", id);
+                    removed.push(`preference #${id}`);
+                }
+                else if (kind === "lessons") {
+                    delLesson.run(id);
+                    removeSearchIndex("lessons", id);
+                    removed.push(`lesson #${id}`);
+                }
+                else {
+                    delInteraction.run(id);
+                    removeSearchIndex("interactions", id);
+                    removed.push(`interaction #${id}`);
+                }
+            }
+        })();
+        if (removed.length === 0) {
+            return ok(`nothing found with id=${id}${args.type ? ` (${args.type})` : ""}`);
+        }
+        return ok(`forgot ${removed.join(", ")}`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/history.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { db, escapeLike, truncate, ok, err, } from "../db.js";
+export const searchHistoryInput = {
+    query: z.string().min(1).max(500).describe("Text to search in past prompts"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("Max results (default 10)"),
+};
+const ITEM_BUDGET = 200;
+const searchPrompts = db.prepare("SELECT ts, content FROM interactions WHERE kind = 'prompt' AND content LIKE ? ESCAPE '\\' ORDER BY ts DESC LIMIT ?");
+export async function searchHistoryHandler(args) {
+    try {
+        const limit = args.limit;
+        const like = `%${escapeLike(args.query)}%`;
+        const rows = searchPrompts.all(like, limit);
+        if (rows.length === 0) {
+            return ok(`no prompts found matching "${truncate(args.query, 100)}"`);
+        }
+        const lines = rows.map((r) => `- [${r.ts}] ${truncate(r.content, ITEM_BUDGET)}`);
+        return ok(lines.join("\n"));
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/lesson.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { db, nowISO, syncSearchIndex, ok, err, } from "../db.js";
+export const saveLessonInput = {
+    situation: z.string().min(1).max(1000).describe("The original situation/context"),
+    mistake: z.string().min(1).max(1000).describe("What was done wrong"),
+    correction: z.string().min(1).max(1000).describe("The correct approach"),
+};
+const LESSON_TITLE_MAX = 80;
+const insertLesson = db.prepare("INSERT INTO lessons (situation, mistake, correction, created_at) VALUES (?, ?, ?, ?)");
+export async function saveLessonHandler(args) {
+    try {
+        const res = insertLesson.run(args.situation, args.mistake, args.correction, nowISO());
+        const id = Number(res.lastInsertRowid);
+        syncSearchIndex("lessons", id, args.situation.slice(0, LESSON_TITLE_MAX), `${args.situation} | mistake: ${args.mistake} -> correction: ${args.correction}`);
+        return ok(`lesson saved (lesson id=${id})`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/memory_stats.js

@@ -0,0 +1,50 @@
+import { statSync } from "node:fs";
+import { db, DB_PATH, truncate, ok, err, } from "../db.js";
+import { CAPTURE_KINDS } from "../lib/capture-core.js";
+export const STATS_BUDGET = 1500;
+const kindCounts = db.prepare("SELECT kind, COUNT(*) AS n FROM interactions GROUP BY kind");
+const prefCount = db.prepare("SELECT COUNT(*) AS n FROM preferences");
+const lessonCount = db.prepare("SELECT COUNT(*) AS n FROM lessons");
+const interactionRange = db.prepare("SELECT MIN(ts) AS oldest, MAX(ts) AS newest FROM interactions");
+const profileSections = db.prepare("SELECT section, updated_at FROM profile ORDER BY section");
+export async function memoryStatsHandler() {
+    try {
+        const lines = [];
+        const kinds = kindCounts.all();
+        const byKind = new Map(kinds.map((k) => [k.kind, k.n]));
+        const total = kinds.reduce((s, k) => s + k.n, 0);
+        const known = [...CAPTURE_KINDS];
+        const kindText = known.map((k) => `${k}=${byKind.get(k) ?? 0}`).join(", ") +
+            kinds
+                .filter((k) => !known.includes(k.kind))
+                .map((k) => `, ${k.kind}=${k.n}`)
+                .join("");
+        lines.push(`interactions: ${total} total (${kindText})`);
+        let dbSize = -1;
+        try {
+            dbSize = statSync(DB_PATH).size;
+        }
+        catch { }
+        lines.push(`db file: ${DB_PATH}${dbSize >= 0 ? ` (${dbSize} bytes)` : " (not found)"}`);
+        const range = interactionRange.get();
+        if (range.oldest && range.newest) {
+            lines.push(`oldest interaction: ${range.oldest}`);
+            lines.push(`newest interaction: ${range.newest}`);
+        }
+        lines.push(`preferences: ${prefCount.get().n}`);
+        lines.push(`lessons: ${lessonCount.get().n}`);
+        const prof = profileSections.all();
+        if (prof.length > 0) {
+            const latest = prof.reduce((a, b) => a.updated_at > b.updated_at ? a : b);
+            lines.push(`profile sections: ${prof.map((p) => p.section).join(", ")}`);
+            lines.push(`profile latest update: ${latest.updated_at}`);
+        }
+        else {
+            lines.push("profile sections: (none)");
+        }
+        return ok(truncate(lines.join("\n"), STATS_BUDGET));
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/profile.js

@@ -0,0 +1,46 @@
+import { db, truncate, ok, err, } from "../db.js";
+export const PROFILE_BUDGET = 3000;
+const PROFILE_SECTION_MAX = 400;
+const PREF_CATEGORY_MAX = 30;
+const PREF_VALUE_MAX = 120;
+const LESSON_SITUATION_MAX = 100;
+const LESSON_MISTAKE_MAX = 120;
+const LESSON_CORRECTION_MAX = 150;
+const profileRows = db.prepare("SELECT section, content FROM profile");
+const topPrefs = db.prepare("SELECT category, key, value, confidence FROM preferences ORDER BY confidence DESC, updated_at DESC LIMIT 15");
+const recentLessons = db.prepare("SELECT situation, mistake, correction FROM lessons ORDER BY created_at DESC, id DESC LIMIT 5");
+export function buildProfileText() {
+    const parts = [];
+    const prof = profileRows.all();
+    for (const p of prof) {
+        parts.push(`[${p.section}]\n${truncate(p.content, PROFILE_SECTION_MAX)}`);
+    }
+    const prefs = topPrefs.all();
+    if (prefs.length > 0) {
+        let block = "[preferences]";
+        for (const p of prefs) {
+            block += `\n- (${p.confidence.toFixed(2)}) ${truncate(p.category, PREF_CATEGORY_MAX)}/${p.key}: ${truncate(p.value, PREF_VALUE_MAX)}`;
+        }
+        parts.push(block);
+    }
+    else {
+        parts.push("[preferences]\n(none yet)");
+    }
+    const lessons = recentLessons.all();
+    if (lessons.length > 0) {
+        let block = "[lessons]";
+        for (const l of lessons) {
+            block += `\n- ${truncate(l.situation, LESSON_SITUATION_MAX)} | mistake: ${truncate(l.mistake, LESSON_MISTAKE_MAX)} -> ${truncate(l.correction, LESSON_CORRECTION_MAX)}`;
+        }
+        parts.push(block);
+    }
+    return truncate(parts.join("\n\n"), PROFILE_BUDGET);
+}
+export async function getProfileHandler() {
+    try {
+        return ok(buildProfileText());
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/recall.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { db, buildFtsMatch, escapeLike, truncate, ok, err, } from "../db.js";
+export const recallInput = {
+    topic: z.string().min(1).max(500).describe("Topic to recall from memory"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(8)
+        .describe("Max preference/lesson matches (default 8)"),
+};
+const RECALL_BUDGET = 2000;
+const RECENT_INTERACTIONS_LIMIT = 20;
+const searchIndexed = db.prepare("SELECT ref_table, ref_id, title, body FROM search_index WHERE search_index MATCH ? AND ref_table IN ('preferences','lessons') LIMIT ?");
+const recentInteractions = db.prepare(`SELECT ts, kind, content FROM interactions WHERE content LIKE ? ESCAPE '\\' ORDER BY ts DESC LIMIT ${RECENT_INTERACTIONS_LIMIT}`);
+export async function recallHandler(args) {
+    try {
+        const limit = args.limit;
+        const parts = [];
+        let prefLines = "";
+        let lessonLines = "";
+        try {
+            const rows = searchIndexed.all(buildFtsMatch(args.topic), limit);
+            for (const r of rows) {
+                if (r.ref_table === "preferences") {
+                    prefLines += `- ${truncate(r.title, 120)} | ${truncate(r.body, 200)}\n`;
+                }
+                else if (r.ref_table === "lessons") {
+                    lessonLines += `- ${truncate(r.title, 120)} | ${truncate(r.body, 300)}\n`;
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error("[recall] preference/lesson search failed:", msg);
+            prefLines = "";
+            lessonLines = "";
+        }
+        let interactionLines = "";
+        try {
+            const like = `%${escapeLike(args.topic)}%`;
+            const rows = recentInteractions.all(like);
+            for (const r of rows) {
+                interactionLines += `- [${r.ts}] (${r.kind}) ${truncate(r.content, 150)}\n`;
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error("[recall] interaction search failed:", msg);
+            interactionLines = "";
+        }
+        if (prefLines)
+            parts.push(`[preferences]\n${prefLines.trimEnd()}`);
+        if (lessonLines)
+            parts.push(`[lessons]\n${lessonLines.trimEnd()}`);
+        if (interactionLines)
+            parts.push(`[recent interactions matching "${truncate(args.topic, 80)}"]\n${interactionLines.trimEnd()}`);
+        if (parts.length === 0) {
+            return ok(`no memory found for "${truncate(args.topic, 100)}"`);
+        }
+        return ok(truncate(parts.join("\n\n"), RECALL_BUDGET));
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/recent_interactions.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { db, truncate, ok, err } from "../db.js";
+import { CAPTURE_KINDS, } from "../lib/capture-core.js";
+export const recentInteractionsInput = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(20)
+        .describe("Max rows (default 20, max 100)"),
+    kind: z
+        .enum(CAPTURE_KINDS)
+        .optional()
+        .describe("Filter by kind (prompt / tool_call / error)"),
+};
+const RECENT_BUDGET = 4000;
+const ITEM_BUDGET = 300;
+const selectAny = db.prepare("SELECT id, ts, kind, content FROM interactions ORDER BY id DESC LIMIT ?");
+const selectByKind = db.prepare("SELECT id, ts, kind, content FROM interactions WHERE kind = ? ORDER BY id DESC LIMIT ?");
+export async function getRecentInteractionsHandler(args) {
+    try {
+        const limit = args.limit;
+        const rows = (args.kind
+            ? selectByKind.all(args.kind, limit)
+            : selectAny.all(limit));
+        if (rows.length === 0) {
+            return ok(`no interactions found${args.kind ? ` with kind '${args.kind}'` : ""}`);
+        }
+        const lines = rows.map((r) => `[${r.id}] ${r.ts} [${r.kind}] ${truncate(r.content, ITEM_BUDGET)}`);
+        return ok(truncate(lines.join("\n"), RECENT_BUDGET));
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/remember.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { db, nowISO, syncSearchIndex, ok, err, } from "../db.js";
+export const rememberInput = {
+    category: z
+        .enum(["work_style", "coding_pref", "language", "domain", "other"])
+        .describe("Preference category"),
+    key: z.string().min(1).max(200).describe("Short stable key, e.g. package_manager"),
+    value: z.string().min(1).max(2000).describe("The preference value"),
+};
+const CONFIDENCE_INITIAL = 0.5;
+const CONFIDENCE_STEP = 0.1;
+const CONFIDENCE_MAX = 1.0;
+const selectPref = db.prepare("SELECT id, confidence FROM preferences WHERE category = @category AND key = @key");
+const insertPref = db.prepare(`INSERT INTO preferences (category, key, value, confidence, source, updated_at) VALUES (?, ?, ?, ${CONFIDENCE_INITIAL}, 'explicit', ?)`);
+const updatePref = db.prepare(`UPDATE preferences SET value = ?, confidence = MIN(confidence + ${CONFIDENCE_STEP}, ${CONFIDENCE_MAX}), updated_at = ? WHERE id = ?`);
+export async function rememberHandler(args) {
+    try {
+        const existing = selectPref.get({ category: args.category, key: args.key });
+        let id;
+        let confidence;
+        if (existing) {
+            updatePref.run(args.value, nowISO(), existing.id);
+            id = existing.id;
+            confidence = Math.min(existing.confidence + CONFIDENCE_STEP, CONFIDENCE_MAX);
+        }
+        else {
+            const res = insertPref.run(args.category, args.key, args.value, nowISO());
+            id = Number(res.lastInsertRowid);
+            confidence = CONFIDENCE_INITIAL;
+        }
+        syncSearchIndex("preferences", id, `${args.category}/${args.key}`, `${args.key}: ${args.value}`);
+        return ok(`remembered [${args.category}] ${args.key} = ${args.value} (preference id=${id}, confidence=${confidence.toFixed(2)})`);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
+}

package/opencode.example.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "memory": {
+      "type": "local",
+      "command": ["node", "<ABSOLUTE_PATH>/th-memory-mcp/dist/index.js"],
+      "enabled": true,
+      "environment": {
+        "MEMORY_DB_PATH": "<ABSOLUTE_PATH>/th-memory-mcp/data/memory.db"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "th-memory-mcp",
+  "version": "1.1.0",
+  "description": "Adaptive Memory MCP server - SQLite-backed memory for OpenCode",
+  "author": "worakorn-prince",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/worakorn-prince/th-memory-mcp.git"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "th-memory-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "design.md",
+    "opencode.example.json",
+    "AGENTS.memory.example.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "test": "npm run build && node test/capture.test.mjs && node test/distill.test.mjs && node test/smoke.mjs",
+    "distill": "node dist/distill.js",
+    "quickstart": "npm run build && node scripts/quickstart.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^12.0.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}