stackmem 1.0.0

package/dist/config.js

@@ -0,0 +1,2 @@
+export const SUPABASE_URL = "https://vuplpnwwygojkwxwsnip.supabase.co";
+export const SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZ1cGxwbnd3eWdvamt3eHdzbmlwIiwicm9sZSI6ImFub24iLCJpYXQiOjE3OTA0NjU2MjIsImV4cCI6MjEwNjA0MTYyMn0.gIIWuALWlOAzKRD3AAQVHnCNq-o4mVOHOgHJKc0fmYs";

package/dist/device.js

@@ -0,0 +1,30 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const DEVICE_DIR = path.join(os.homedir(), ".stackmem");
+const DEVICE_FILE = path.join(DEVICE_DIR, "device.json");
+let cachedDeviceId = null;
+// Every request is scoped to this id (see storage.ts), so it's effectively
+// a bearer credential for whatever this device has saved — treat device.json
+// like a secret, not just a preference file.
+export function getDeviceId() {
+    if (cachedDeviceId)
+        return cachedDeviceId;
+    try {
+        const raw = fs.readFileSync(DEVICE_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.device_id === "string" && parsed.device_id.length > 0) {
+            cachedDeviceId = parsed.device_id;
+            return parsed.device_id;
+        }
+    }
+    catch {
+        // No device file yet, or it's unreadable/corrupt — create a fresh one below.
+    }
+    const deviceId = randomUUID();
+    fs.mkdirSync(DEVICE_DIR, { recursive: true });
+    fs.writeFileSync(DEVICE_FILE, JSON.stringify({ device_id: deviceId }, null, 2), "utf-8");
+    cachedDeviceId = deviceId;
+    return deviceId;
+}

package/dist/index.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { analyzeCodebase, getFileSummary, findDependencies } from "./ast-index.js";
+import { getDeviceId } from "./device.js";
+import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, } from "./scoring.js";
+import { supabase } from "./storage.js";
+const CONTEXT_BUDGET_TOKENS = 2000;
+const COMPRESSION_THRESHOLD = 20;
+const server = new McpServer({
+    name: "coding-memory",
+    version: "1.0.0",
+});
+// --- session_start -----------------------------------------------------
+server.registerTool("session_start", {
+    title: "Session Start",
+    description: "Signal the start of a coding session for a given project.",
+    inputSchema: {
+        project: z.string().describe("Project identifier"),
+    },
+}, async ({ project }) => {
+    const { data, error } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (error) {
+        throw new Error(`Failed to load memories: ${error.message}`);
+    }
+    const memories = data ?? [];
+    const scoredMemories = memories
+        .map((memory) => ({
+        ...memory,
+        decay_score: computeDecayScore(new Date(memory.created_at), memory.access_count ?? 0),
+    }))
+        .sort((a, b) => b.decay_score - a.decay_score);
+    const budgetedMemories = applyContextBudget(scoredMemories, CONTEXT_BUDGET_TOKENS);
+    const omittedCount = scoredMemories.length - budgetedMemories.length;
+    const tokensUsed = budgetedMemories.reduce((sum, memory) => sum + estimateTokens(memory.content), 0);
+    const memoryIds = budgetedMemories.map((m) => m.id);
+    const linkedIdsByMemory = new Map();
+    if (memoryIds.length > 0) {
+        const idList = memoryIds.join(",");
+        const { data: links, error: linksError } = await supabase
+            .from("memory_links")
+            .select("source_id, target_id")
+            .or(`source_id.in.(${idList}),target_id.in.(${idList})`);
+        if (linksError) {
+            throw new Error(`Failed to load memory links: ${linksError.message}`);
+        }
+        for (const link of links ?? []) {
+            if (!linkedIdsByMemory.has(link.source_id))
+                linkedIdsByMemory.set(link.source_id, new Set());
+            if (!linkedIdsByMemory.has(link.target_id))
+                linkedIdsByMemory.set(link.target_id, new Set());
+            linkedIdsByMemory.get(link.source_id).add(link.target_id);
+            linkedIdsByMemory.get(link.target_id).add(link.source_id);
+        }
+    }
+    const memoriesWithLinks = budgetedMemories.map((m) => ({
+        ...m,
+        linked_memory_ids: Array.from(linkedIdsByMemory.get(m.id) ?? []),
+    }));
+    if (budgetedMemories.length > 0) {
+        const incrementResults = await Promise.all(budgetedMemories.map((memory) => supabase
+            .from("memories")
+            .update({ access_count: (memory.access_count ?? 0) + 1 })
+            .eq("id", memory.id)));
+        const incrementError = incrementResults.find((result) => result.error)?.error;
+        if (incrementError) {
+            throw new Error(`Failed to update access counts: ${incrementError.message}`);
+        }
+    }
+    const budgetText = omittedCount > 0
+        ? `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used, ${omittedCount} omitted for budget).`
+        : `Loaded ${memories.length} memory row(s) for "${project}" (${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used).`;
+    return {
+        content: [{ type: "text", text: budgetText }],
+        structuredContent: {
+            memories: memoriesWithLinks,
+            context_budget: {
+                budget_tokens: CONTEXT_BUDGET_TOKENS,
+                tokens_used: tokensUsed,
+                omitted_count: omittedCount,
+            },
+        },
+    };
+});
+// --- memory compression ----------------------------------------------------
+async function compressMemories(project) {
+    const { data, error } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (error) {
+        throw new Error(`Failed to load memories for compression: ${error.message}`);
+    }
+    const memories = data ?? [];
+    if (memories.length < COMPRESSION_THRESHOLD) {
+        return { totalUnresolved: memories.length, clustersCompressed: 0 };
+    }
+    const clusters = clusterMemories(memories);
+    let clustersCompressed = 0;
+    for (const cluster of clusters) {
+        if (cluster.length < 3)
+            continue;
+        const summaryContent = buildSummaryContent(cluster);
+        const { error: insertError } = await supabase
+            .from("memories")
+            .insert({ project, type: "discovery", content: summaryContent, device_id: getDeviceId() });
+        if (insertError) {
+            throw new Error(`Failed to insert summary memory: ${insertError.message}`);
+        }
+        const idsToResolve = cluster.map((memory) => memory.id);
+        const { error: resolveError } = await supabase
+            .from("memories")
+            .update({ resolved: true })
+            .in("id", idsToResolve);
+        if (resolveError) {
+            throw new Error(`Failed to resolve compressed memories: ${resolveError.message}`);
+        }
+        console.error(`Compressed ${cluster.length} memories into 1 summary`);
+        clustersCompressed++;
+    }
+    console.error(`Compression complete. ${clustersCompressed} clusters compressed.`);
+    return { totalUnresolved: memories.length, clustersCompressed };
+}
+// --- save_memory ---------------------------------------------------------
+const memoryTypeEnum = z.enum([
+    "decision",
+    "rejection",
+    "constraint",
+    "discovery",
+]);
+server.registerTool("save_memory", {
+    title: "Save Memory",
+    description: "Persist a piece of project memory (decision, rejection, constraint, or discovery).",
+    inputSchema: {
+        project: z.string().describe("Project identifier"),
+        type: memoryTypeEnum.describe("Category of memory being saved"),
+        content: z.string().describe("The memory content to save"),
+    },
+}, async ({ project, type, content }) => {
+    const { data: existingRows, error: existingError } = await supabase
+        .from("memories")
+        .select("id, content")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (existingError) {
+        throw new Error(`Failed to load memories: ${existingError.message}`);
+    }
+    const existingMemories = existingRows ?? [];
+    const decision = decideSaveAction(content, existingMemories);
+    if (decision.action === "duplicate") {
+        return {
+            content: [{ type: "text", text: "Duplicate memory detected — skipping." }],
+            structuredContent: {
+                saved: false,
+                reason: "duplicate",
+                matched_id: decision.matchedId,
+            },
+        };
+    }
+    if (decision.action === "superseded") {
+        const { error: resolveError } = await supabase
+            .from("memories")
+            .update({ resolved: true })
+            .eq("id", decision.oldId);
+        if (resolveError) {
+            throw new Error(`Failed to resolve superseded memory: ${resolveError.message}`);
+        }
+    }
+    const { data: inserted, error } = await supabase
+        .from("memories")
+        .insert({ project, type, content, device_id: getDeviceId() })
+        .select("id")
+        .single();
+    if (error || !inserted) {
+        throw new Error(`Failed to save memory: ${error?.message ?? "no row returned"}`);
+    }
+    const newMemoryId = inserted.id;
+    const links = computeMemoryLinks(newMemoryId, content, existingMemories);
+    if (links.length > 0) {
+        const { error: linkError } = await supabase.from("memory_links").insert(links);
+        if (linkError) {
+            throw new Error(`Failed to save memory links: ${linkError.message}`);
+        }
+    }
+    const { count: unresolvedCount, error: countError } = await supabase
+        .from("memories")
+        .select("id", { count: "exact", head: true })
+        .eq("project", project)
+        .eq("resolved", false);
+    if (countError) {
+        throw new Error(`Failed to count memories: ${countError.message}`);
+    }
+    if ((unresolvedCount ?? 0) >= COMPRESSION_THRESHOLD) {
+        await compressMemories(project);
+    }
+    if (decision.action === "superseded") {
+        return {
+            content: [{ type: "text", text: `Superseded previous memory [${decision.oldId}].` }],
+            structuredContent: { saved: true, action: "superseded", old_id: decision.oldId },
+        };
+    }
+    return {
+        content: [{ type: "text", text: "Memory saved." }],
+        structuredContent: { saved: true, action: "created" },
+    };
+});
+// --- search_past_solutions -------------------------------------------------
+server.registerTool("search_past_solutions", {
+    title: "Search Past Solutions",
+    description: "Search previously recorded memory/fixes for a project matching a query.",
+    inputSchema: {
+        project: z.string().describe("Project identifier"),
+        query: z.string().describe("Search query"),
+    },
+}, async ({ project, query }) => {
+    void query;
+    const { data, error } = await supabase
+        .from("execution_log")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (error) {
+        throw new Error(`Failed to search past solutions: ${error.message}`);
+    }
+    const results = data ?? [];
+    return {
+        content: [{ type: "text", text: `Found ${results.length} result(s).` }],
+        structuredContent: { results },
+    };
+});
+// --- record_fix ----------------------------------------------------------
+server.registerTool("record_fix", {
+    title: "Record Fix",
+    description: "Record a problem and its solution for future reference.",
+    inputSchema: {
+        project: z.string().describe("Project identifier"),
+        problem: z.string().describe("Description of the problem"),
+        solution: z.string().describe("Description of the solution/fix"),
+    },
+}, async ({ project, problem, solution }) => {
+    const { error } = await supabase
+        .from("execution_log")
+        .insert({ project, problem, solution, resolved: false, device_id: getDeviceId() });
+    if (error) {
+        throw new Error(`Failed to record fix: ${error.message}`);
+    }
+    const saved = true;
+    return {
+        content: [{ type: "text", text: "Fix recorded." }],
+        structuredContent: { saved },
+    };
+});
+// --- analyze_codebase ------------------------------------------------------
+server.registerTool("analyze_codebase", {
+    title: "Analyze Codebase",
+    description: "Build a lightweight AST index of a project's .ts/.js files (functions, classes, imports) into a local SQLite database at <project_path>/.coding-memory/ast-index.db.",
+    inputSchema: {
+        project_path: z.string().describe("Absolute or relative path to the project to index"),
+    },
+}, async ({ project_path }) => {
+    const summary = analyzeCodebase(project_path);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Indexed ${summary.files_indexed} file(s): ${summary.functions} function(s), ${summary.classes} class(es).`,
+            },
+        ],
+        structuredContent: summary,
+    };
+});
+// --- get_file_summary --------------------------------------------------------
+server.registerTool("get_file_summary", {
+    title: "Get File Summary",
+    description: "Look up the functions and classes recorded for a file in the project's AST index. Requires analyze_codebase to have been run first.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project that was indexed"),
+        file_name: z.string().describe("File name or relative path to look up"),
+    },
+}, async ({ project_path, file_name }) => {
+    const summary = getFileSummary(project_path, file_name);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${summary.file_path}: ${summary.functions.length} function(s), ${summary.classes.length} class(es).`,
+            },
+        ],
+        structuredContent: summary,
+    };
+});
+// --- find_dependencies ----------------------------------------------------
+server.registerTool("find_dependencies", {
+    title: "Find Dependencies",
+    description: "Look up what a file imports, based on the project's AST index. Requires analyze_codebase to have been run first.",
+    inputSchema: {
+        project_path: z.string().describe("Path to the project that was indexed"),
+        file_name: z.string().describe("File name or relative path to look up"),
+    },
+}, async ({ project_path, file_name }) => {
+    const deps = findDependencies(project_path, file_name);
+    return {
+        content: [
+            { type: "text", text: `${deps.file_path} imports ${deps.imports.length} module(s).` },
+        ],
+        structuredContent: deps,
+    };
+});
+// --- transport -------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("coding-memory MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error starting coding-memory MCP server:", error);
+    process.exit(1);
+});

package/dist/scoring.js

@@ -0,0 +1,217 @@
+// --- semantic linking ------------------------------------------------------
+const STOP_WORDS = new Set([
+    "we", "use", "for", "all", "a", "the", "is", "has", "have", "are", "to",
+    "of", "in", "it", "this", "that", "with", "and", "or", "but",
+]);
+const MIN_ENTITY_LENGTH = 5;
+// Key entities: words longer than 4 characters that aren't stop words.
+// Short/common words carry little identifying signal for a memory.
+export function extractEntities(text) {
+    const entities = new Set();
+    for (const word of text.toLowerCase().split(/\W+/)) {
+        if (word.length < MIN_ENTITY_LENGTH || STOP_WORDS.has(word))
+            continue;
+        entities.add(word);
+    }
+    return entities;
+}
+// Containment score: shared entities over the SMALLER of the two entity
+// sets, so a short memory whose terms are fully covered by a longer one
+// still scores highly — unlike Jaccard, which penalizes size mismatches.
+export function containmentScore(entitiesA, entitiesB) {
+    const smallerSize = Math.min(entitiesA.size, entitiesB.size);
+    if (smallerSize === 0)
+        return 0;
+    let shared = 0;
+    for (const entity of entitiesA) {
+        if (entitiesB.has(entity))
+            shared += 1;
+    }
+    return shared / smallerSize;
+}
+export function computeMemoryLinks(newMemoryId, newContent, existingMemories, threshold = 0.15) {
+    const newEntities = extractEntities(newContent);
+    return existingMemories
+        .map((existing) => ({
+        source_id: newMemoryId,
+        target_id: existing.id,
+        score: containmentScore(newEntities, extractEntities(existing.content)),
+    }))
+        .filter((link) => link.score > threshold);
+}
+// --- save-memory CRUD decision ------------------------------------------
+const DUPLICATE_THRESHOLD = 0.85;
+const CONTRADICTION_MIN = 0.4;
+// Words that signal the new memory is meant to replace an old one rather
+// than just relate to it (e.g. "we switched from X to Y").
+const NEGATION_WORDS = [
+    "switched", "removed", "replaced", "no longer", "instead",
+    "deprecated", "reverted", "changed",
+];
+function containsNegationWord(text) {
+    const lower = text.toLowerCase();
+    return NEGATION_WORDS.some((word) => lower.includes(word));
+}
+// Decides whether a new memory is a near-duplicate of an existing one
+// (skip it), supersedes an existing one (resolve the old, insert the new),
+// or is genuinely new. A negation word (e.g. "switched", "no longer")
+// reroutes an otherwise-duplicate-level score into a supersede instead —
+// without that carve-out, a "switched from X to Y" memory that repeats X's
+// keywords would score as a duplicate of the memory it's meant to replace.
+// Scanning finds the best-scoring match in each band rather than stopping
+// at the first hit, so the result doesn't depend on row order.
+export function decideSaveAction(newContent, existingMemories) {
+    const newEntities = extractEntities(newContent);
+    const hasNegation = containsNegationWord(newContent);
+    let bestDuplicate = null;
+    let bestSupersede = null;
+    for (const existing of existingMemories) {
+        const score = containmentScore(newEntities, extractEntities(existing.content));
+        if (score > DUPLICATE_THRESHOLD) {
+            if (hasNegation) {
+                if (!bestSupersede || score > bestSupersede.score) {
+                    bestSupersede = { id: existing.id, score };
+                }
+            }
+            else if (!bestDuplicate || score > bestDuplicate.score) {
+                bestDuplicate = { id: existing.id, score };
+            }
+        }
+        else if (hasNegation && score >= CONTRADICTION_MIN) {
+            if (!bestSupersede || score > bestSupersede.score) {
+                bestSupersede = { id: existing.id, score };
+            }
+        }
+    }
+    if (bestDuplicate)
+        return { action: "duplicate", matchedId: bestDuplicate.id };
+    if (bestSupersede)
+        return { action: "superseded", oldId: bestSupersede.id };
+    return { action: "created" };
+}
+// --- memory decay --------------------------------------------------------
+// Decay constant tuned for a ~14-day half-life: exp(-0.05 * 14) ≈ 0.5.
+const DECAY_LAMBDA = 0.05;
+// Recency-weighted relevance: frequently-accessed memories decay slower,
+// but every memory still fades over time regardless of access count.
+export function computeDecayScore(createdAt, accessCount) {
+    const daysSinceCreated = (Date.now() - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+    return (1 + Math.log(1 + accessCount)) * Math.exp(-DECAY_LAMBDA * daysSinceCreated);
+}
+// --- context budget ------------------------------------------------------
+// Rough token estimate: ~4 characters per token.
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// Takes a decay-sorted memory array (highest relevance first) and keeps
+// adding memories until the next one would push the running token count
+// over budget, so what gets injected into an agent's context stays capped.
+export function applyContextBudget(memories, budgetTokens) {
+    const result = [];
+    let usedTokens = 0;
+    for (const memory of memories) {
+        const tokens = estimateTokens(memory.content);
+        if (usedTokens + tokens > budgetTokens)
+            break;
+        result.push(memory);
+        usedTokens += tokens;
+    }
+    return result;
+}
+// --- memory compression --------------------------------------------------
+const CLUSTER_THRESHOLD = 0.2;
+// Single-linkage clustering over containment score: two memories join the
+// same cluster if they score > 0.2, and clusters merge transitively (via
+// union-find) even if the two memories that join them don't directly score
+// above the threshold themselves.
+export function clusterMemories(memories) {
+    const parent = memories.map((_, index) => index);
+    function find(index) {
+        while (parent[index] !== index) {
+            parent[index] = parent[parent[index]];
+            index = parent[index];
+        }
+        return index;
+    }
+    function union(a, b) {
+        const rootA = find(a);
+        const rootB = find(b);
+        if (rootA !== rootB)
+            parent[rootA] = rootB;
+    }
+    const entities = memories.map((memory) => extractEntities(memory.content));
+    for (let i = 0; i < memories.length; i++) {
+        for (let j = i + 1; j < memories.length; j++) {
+            if (containmentScore(entities[i], entities[j]) > CLUSTER_THRESHOLD) {
+                union(i, j);
+            }
+        }
+    }
+    const clustersByRoot = new Map();
+    for (let i = 0; i < memories.length; i++) {
+        const root = find(i);
+        if (!clustersByRoot.has(root))
+            clustersByRoot.set(root, []);
+        clustersByRoot.get(root).push(memories[i]);
+    }
+    return Array.from(clustersByRoot.values());
+}
+const SUMMARY_ITEM_LENGTH = 60;
+// Builds a compact summary for a cluster of related memories: the most
+// common type in the cluster, the most frequent shared entity as the
+// "topic", and each memory's content truncated and joined.
+export function buildSummaryContent(cluster) {
+    const typeCounts = new Map();
+    for (const memory of cluster) {
+        typeCounts.set(memory.type, (typeCounts.get(memory.type) ?? 0) + 1);
+    }
+    let mostCommonType = cluster[0]?.type ?? "discovery";
+    let maxTypeCount = 0;
+    for (const [type, count] of typeCounts) {
+        if (count > maxTypeCount) {
+            maxTypeCount = count;
+            mostCommonType = type;
+        }
+    }
+    const entityCounts = new Map();
+    for (const memory of cluster) {
+        for (const entity of extractEntities(memory.content)) {
+            entityCounts.set(entity, (entityCounts.get(entity) ?? 0) + 1);
+        }
+    }
+    let topic = "general";
+    let maxEntityCount = 0;
+    for (const [entity, count] of entityCounts) {
+        if (count > maxEntityCount) {
+            maxEntityCount = count;
+            topic = entity;
+        }
+    }
+    const items = cluster
+        .map((memory) => memory.content.slice(0, SUMMARY_ITEM_LENGTH))
+        .join("; ");
+    return `[${mostCommonType.toUpperCase()} cluster] ${topic}: ${items}`;
+}
+// --- task relevance --------------------------------------------------------
+function splitWords(text) {
+    return text
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((word) => word.length > 0 && !STOP_WORDS.has(word));
+}
+// Blends entity containment (structural overlap) with raw word overlap
+// (surface-level phrasing match) so a memory that shares the task's exact
+// wording scores well even if its extracted entities don't line up neatly.
+export function scoreMemoryRelevance(memoryContent, task) {
+    const containment = containmentScore(extractEntities(memoryContent), extractEntities(task));
+    const memoryWords = new Set(splitWords(memoryContent));
+    const taskWords = splitWords(task);
+    let shared = 0;
+    for (const word of taskWords) {
+        if (memoryWords.has(word))
+            shared++;
+    }
+    const wordOverlapRatio = taskWords.length === 0 ? 0 : shared / taskWords.length;
+    return containment * 0.7 + wordOverlapRatio * 0.3;
+}
+// TODO: optimize the clustering algorithm

package/dist/storage.js

@@ -0,0 +1,53 @@
+// Run these in the Supabase SQL editor after changing the RLS scoping
+// mechanism from a session-config RPC to a request header. `set_config` from
+// an RPC call doesn't persist to the next request under PostgREST (each call
+// is its own transaction), so RLS now reads the 'x-device-id' header that
+// supabase-js attaches to every request instead.
+//
+// DROP POLICY IF EXISTS "device owns memories" ON memories;
+// CREATE POLICY "device owns memories" ON memories
+// USING (device_id = (current_setting('request.headers', true)::json->>'x-device-id'))
+// WITH CHECK (device_id = (current_setting('request.headers', true)::json->>'x-device-id'));
+//
+// DROP POLICY IF EXISTS "device owns execution_log" ON execution_log;
+// CREATE POLICY "device owns execution_log" ON execution_log
+// USING (device_id = (current_setting('request.headers', true)::json->>'x-device-id'))
+// WITH CHECK (device_id = (current_setting('request.headers', true)::json->>'x-device-id'));
+//
+// DROP POLICY IF EXISTS "device owns memory_links" ON memory_links;
+// CREATE POLICY "device owns memory_links" ON memory_links
+// USING (
+//   source_id in (
+//     select id from memories
+//     where device_id = (current_setting('request.headers', true)::json->>'x-device-id')
+//   )
+// );
+import { createClient } from "@supabase/supabase-js";
+import { SUPABASE_ANON_KEY, SUPABASE_URL } from "./config.js";
+import { getDeviceId } from "./device.js";
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    global: {
+        headers: {
+            "x-device-id": getDeviceId(),
+        },
+    },
+});
+// Run this migration in the Supabase SQL editor to add the access_count
+// column used by the memory decay scoring in src/scoring.ts (computeDecayScore)
+// and consumed by cm start / session_start in src/cli.ts and src/index.ts.
+//
+// ALTER TABLE memories ADD COLUMN IF NOT EXISTS access_count integer default 0;
+// Run this migration in the Supabase SQL editor to create the memory_links
+// table used by the semantic linking system in src/index.ts (save_memory /
+// session_start). Assumes memories.id is a uuid, matching Supabase's default.
+//
+// create table memory_links (
+//   id uuid primary key default gen_random_uuid(),
+//   source_id uuid not null references memories(id) on delete cascade,
+//   target_id uuid not null references memories(id) on delete cascade,
+//   score double precision not null,
+//   created_at timestamptz not null default now()
+// );
+//
+// create index memory_links_source_id_idx on memory_links(source_id);
+// create index memory_links_target_id_idx on memory_links(target_id);

package/dist/test-scoring.js

@@ -0,0 +1,7 @@
+import { extractEntities, containmentScore } from "./scoring.js";
+const textA = "we use Supabase for database storage";
+const textB = "Supabase free tier has 500MB limit";
+const entitiesA = extractEntities(textA);
+const entitiesB = extractEntities(textB);
+const score = containmentScore(entitiesA, entitiesB);
+console.log(`SCORE: [${textA}] vs [${textB}] = ${score}`);

package/dist/tools.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "stackmem",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "cm": "src/cli.ts"
+  },
+  "files": ["dist", "src"],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "cli": "tsx src/cli.ts",
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@supabase/supabase-js": "^2.116.0",
+    "better-sqlite3": "^13.0.3",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-typescript": "^0.23.2",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/node": "^22.20.3",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
+  }
+}