stackmem 1.0.14 → 1.0.16

package/dist/cli.js

@@ -234,6 +234,8 @@ async function cmdStart(project) {
     const memories = data ?? [];
     if (memories.length === 0) {
         console.log(`No memories found for "${project}".`);
+        console.log("");
+        console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
         return;
     }
     const scoredMemories = memories
@@ -244,7 +246,26 @@ async function cmdStart(project) {
         .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);
+    let tokensUsed = budgetedMemories.reduce((sum, memory) => sum + estimateTokens(memory.content), 0);
+    const { data: fixData, error: fixError } = await supabase
+        .from("execution_log")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false)
+        .order("created_at", { ascending: false })
+        .limit(5);
+    if (fixError)
+        fail(`Failed to load execution log: ${fixError.message}`);
+    // Fixes share the same 2000-token budget as memories, which already
+    // consumed their portion above — fixes only get whatever room is left.
+    const budgetedFixes = [];
+    for (const fix of fixData ?? []) {
+        const tokens = estimateTokens(`${fix.problem} ${fix.solution ?? ""}`);
+        if (tokensUsed + tokens > CONTEXT_BUDGET_TOKENS)
+            break;
+        budgetedFixes.push(fix);
+        tokensUsed += tokens;
+    }
     const memoryIds = budgetedMemories.map((m) => m.id);
     const linkedIdsByMemory = new Map();
     const idList = memoryIds.join(",");
@@ -278,10 +299,24 @@ async function cmdStart(project) {
         }
         console.log("");
     }
+    if (budgetedFixes.length > 0) {
+        console.log(`Past Fixes (${budgetedFixes.length})`);
+        console.log("-".repeat(14));
+        for (const fix of budgetedFixes) {
+            console.log(`  Problem: ${fix.problem}`);
+            console.log(`  Solution: ${fix.solution ?? "(pending)"}`);
+            console.log("");
+        }
+    }
     console.log(`Context budget: ${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used`);
     if (omittedCount > 0) {
         console.log(`${omittedCount} memories omitted (budget exceeded)`);
     }
+    const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+    if (!hasTechStackMemory) {
+        console.log("");
+        console.log("Tip: run 'cm init' to seed tech stack memories from your project files.");
+    }
     const incrementResults = await Promise.all(budgetedMemories.map((memory) => supabase
         .from("memories")
         .update({ access_count: (memory.access_count ?? 0) + 1 })
@@ -1012,6 +1047,21 @@ function writeProjectFile(project, resolvedPath) {
     const stackmemPath = nodePath.join(resolvedPath, STACKMEM_FILE);
     nodeFs.writeFileSync(stackmemPath, `${project}\n`, "utf-8");
 }
+// Shared by every seedMemories check below: skip the insert if this exact
+// content already exists (decideSaveAction's duplicate check) so re-running
+// `cm init` on an already-seeded project doesn't pile up repeats.
+async function trySeedMemory(project, existingMemories, type, content) {
+    const decision = decideSaveAction(content, existingMemories);
+    if (decision.action === "duplicate")
+        return false;
+    const { error } = await supabase.from("memories").insert({
+        project,
+        type,
+        content,
+        device_id: getDeviceId(),
+    });
+    return !error;
+}
 // Scans the freshly-initialized project for a few cheap, high-signal facts
 // and saves them as memories directly (bypassing cmdSave's duplicate/conflict
 // prompt — there's nothing to conflict with yet, and init must stay
@@ -1036,17 +1086,8 @@ async function seedMemories(project, resolvedPath) {
             ];
             if (depNames.length > 0) {
                 const content = `tech stack: ${depNames.join(", ")}`;
-                const decision = decideSaveAction(content, existingMemories);
-                if (decision.action !== "duplicate") {
-                    const { error } = await supabase.from("memories").insert({
-                        project,
-                        type: "discovery",
-                        content,
-                        device_id: getDeviceId(),
-                    });
-                    if (!error)
-                        seededCount++;
-                }
+                if (await trySeedMemory(project, existingMemories, "discovery", content))
+                    seededCount++;
             }
         }
         catch {
@@ -1062,18 +1103,57 @@ async function seedMemories(project, resolvedPath) {
             .map((line) => line.split("=")[0]);
         if (varNames.length > 0) {
             const content = `required env vars: ${varNames.join(", ")}`;
-            const decision = decideSaveAction(content, existingMemories);
-            if (decision.action !== "duplicate") {
-                const { error } = await supabase.from("memories").insert({
-                    project,
-                    type: "constraint",
-                    content,
-                    device_id: getDeviceId(),
-                });
-                if (!error)
+            if (await trySeedMemory(project, existingMemories, "constraint", content))
+                seededCount++;
+        }
+    }
+    const tsconfigPath = nodePath.join(resolvedPath, "tsconfig.json");
+    if (nodeFs.existsSync(tsconfigPath)) {
+        try {
+            const tsconfig = JSON.parse(nodeFs.readFileSync(tsconfigPath, "utf-8"));
+            const target = tsconfig.compilerOptions?.target;
+            const moduleKind = tsconfig.compilerOptions?.module;
+            if (target || moduleKind) {
+                const content = `TypeScript config: target=${target ?? "unspecified"}, module=${moduleKind ?? "unspecified"}`;
+                if (await trySeedMemory(project, existingMemories, "constraint", content))
                     seededCount++;
             }
         }
+        catch {
+            // Malformed tsconfig.json (or JSONC with comments) — skip.
+        }
+    }
+    const readmePath = nodePath.join(resolvedPath, "README.md");
+    if (nodeFs.existsSync(readmePath)) {
+        const words = nodeFs
+            .readFileSync(readmePath, "utf-8")
+            .split(/\s+/)
+            .filter(Boolean)
+            .slice(0, 100);
+        if (words.length > 0) {
+            const content = `project description: ${words.join(" ")}`;
+            if (await trySeedMemory(project, existingMemories, "discovery", content))
+                seededCount++;
+        }
+    }
+    const FRAMEWORK_FILE_INDICATORS = [
+        { file: "next.config.ts", type: "constraint", content: "framework: Next.js" },
+        { file: "next.config.js", type: "constraint", content: "framework: Next.js" },
+        { file: "vite.config.ts", type: "constraint", content: "framework: Vite" },
+        { file: "vite.config.js", type: "constraint", content: "framework: Vite" },
+        { file: "Dockerfile", type: "constraint", content: "containerized: Docker" },
+    ];
+    for (const indicator of FRAMEWORK_FILE_INDICATORS) {
+        if (!nodeFs.existsSync(nodePath.join(resolvedPath, indicator.file)))
+            continue;
+        if (await trySeedMemory(project, existingMemories, indicator.type, indicator.content))
+            seededCount++;
+    }
+    const githubWorkflowsPath = nodePath.join(resolvedPath, ".github", "workflows");
+    if (nodeFs.existsSync(githubWorkflowsPath)) {
+        const content = "CI/CD: GitHub Actions";
+        if (await trySeedMemory(project, existingMemories, "discovery", content))
+            seededCount++;
     }
     analyzeCodebase(resolvedPath);
     return seededCount;

package/dist/index.js

@@ -62,6 +62,20 @@ server.registerTool("session_start", {
         ...m,
         linked_memory_ids: Array.from(linkedIdsByMemory.get(m.id) ?? []),
     }));
+    const { data: fixData, error: fixError } = await supabase
+        .from("execution_log")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false)
+        .order("created_at", { ascending: false })
+        .limit(5);
+    if (fixError) {
+        throw new Error(`Failed to load execution log: ${fixError.message}`);
+    }
+    const fixes = (fixData ?? []).map((fix) => ({
+        problem: fix.problem,
+        solution: fix.solution ?? "pending",
+    }));
     if (budgetedMemories.length > 0) {
         const incrementResults = await Promise.all(budgetedMemories.map((memory) => supabase
             .from("memories")
@@ -75,10 +89,15 @@ server.registerTool("session_start", {
     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).`;
+    const hasTechStackMemory = memories.some((m) => /^tech stack:/i.test(m.content));
+    const techStackTip = hasTechStackMemory
+        ? ""
+        : "\n\nTip: run 'cm init' to seed tech stack memories from your project files.";
     return {
-        content: [{ type: "text", text: budgetText }],
+        content: [{ type: "text", text: budgetText + techStackTip }],
         structuredContent: {
             memories: memoriesWithLinks,
+            fixes,
             context_budget: {
                 budget_tokens: CONTEXT_BUDGET_TOKENS,
                 tokens_used: tokensUsed,

package/dist/scoring.js

@@ -3,10 +3,31 @@ 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",
 ]);
+// Bumping this from 5 to 6 was considered (see the benchmark's duplicate-
+// detection findings) but doesn't actually fix anything: "removed" is 7
+// chars and "added"/"dependency" aren't the problem either. The real issue
+// is entity-level, not length-based — see DEPENDENCY_TEMPLATE_RE below.
 const MIN_ENTITY_LENGTH = 5;
+// Hook-generated dependency-change templates ("removed dependency: X" /
+// "added dependency: X") reduce to just {"removed"/"added", "dependency"}
+// under generic word-based extraction below, since package names are often
+// short (node:path, zod, ./device.js — all filtered by MIN_ENTITY_LENGTH).
+// That made two DIFFERENT packages removed in different commits look like
+// duplicates of each other. Special-cased here instead: for these
+// templates, the package name itself is the only entity, so containment
+// (and hybridScore) only agrees when the package name actually matches.
+const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
+const DEPENDENCY_PACKAGE_RE = /^(?:removed|added) dependency:\s*(.+)$/i;
+function extractDependencyPackageName(content) {
+    const match = DEPENDENCY_PACKAGE_RE.exec(content.trim());
+    return match ? match[1].trim().toLowerCase() : null;
+}
 // 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 packageName = extractDependencyPackageName(text);
+    if (packageName !== null)
+        return new Set([packageName]);
     const entities = new Set();
     for (const word of text.toLowerCase().split(/\W+/)) {
         if (word.length < MIN_ENTITY_LENGTH || STOP_WORDS.has(word))
@@ -29,13 +50,58 @@ export function containmentScore(entitiesA, entitiesB) {
     }
     return shared / smallerSize;
 }
+function trigramSet(text) {
+    const normalized = text.toLowerCase();
+    if (normalized.length < 3) {
+        return normalized.length > 0 ? new Set([normalized]) : new Set();
+    }
+    const trigrams = new Set();
+    for (let i = 0; i <= normalized.length - 3; i++) {
+        trigrams.add(normalized.slice(i, i + 3));
+    }
+    return trigrams;
+}
+// Character-trigram Jaccard overlap: catches surface-level lexical
+// similarity (typos, partial substrings, shared phrasing) that word-based
+// containment misses entirely, since containment only ever compares whole
+// extracted entities.
+function ngramOverlap(a, b) {
+    const trigramsA = trigramSet(a);
+    const trigramsB = trigramSet(b);
+    const union = new Set([...trigramsA, ...trigramsB]);
+    if (union.size === 0)
+        return 0;
+    let shared = 0;
+    for (const trigram of trigramsA) {
+        if (trigramsB.has(trigram))
+            shared++;
+    }
+    return shared / union.size;
+}
+// Blends entity containment (structural: do the two texts share key
+// extracted terms) with character-trigram overlap (lexical: do the two
+// texts look alike as raw strings) so near-duplicates with slightly
+// different wording still score high even when their extracted entities
+// don't line up neatly, and vice versa.
+//
+// NOTE ON THRESHOLDS: DUPLICATE_THRESHOLD (0.85), CONTRADICTION_MIN (0.4),
+// computeMemoryLinks' default (0.15), and CLUSTER_THRESHOLD (0.2) were all
+// tuned against pure containmentScore. The 0.3 trigram component shifts
+// scores upward for almost any pair sharing common substrings (whitespace,
+// "ing", "the", etc.), so these thresholds may need recalibration —
+// re-validate against src/benchmark.ts rather than assuming they still
+// hold as-is.
+export function hybridScore(a, b) {
+    const containment = containmentScore(extractEntities(a), extractEntities(b));
+    const overlap = ngramOverlap(a, b);
+    return containment * 0.7 + overlap * 0.3;
+}
 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)),
+        score: hybridScore(newContent, existing.content),
     }))
         .filter((link) => link.score > threshold);
 }
@@ -61,12 +127,15 @@ function containsNegationWord(text) {
 // 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);
+    // Dependency-change templates are structural facts, not decisions —
+    // "removed"/"added" would otherwise trip containsNegationWord below, but
+    // there's nothing for them to supersede/contradict, so they're exempted
+    // up front and only ever fall through to the plain duplicate check.
+    const hasNegation = DEPENDENCY_TEMPLATE_RE.test(newContent) ? false : containsNegationWord(newContent);
     let bestDuplicate = null;
     let bestSupersede = null;
     for (const existing of existingMemories) {
-        const score = containmentScore(newEntities, extractEntities(existing.content));
+        const score = hybridScore(newContent, existing.content);
         if (score > DUPLICATE_THRESHOLD) {
             if (hasNegation) {
                 if (!bestSupersede || score > bestSupersede.score) {
@@ -139,10 +208,9 @@ export function clusterMemories(memories) {
         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) {
+            if (hybridScore(memories[i].content, memories[j].content) > CLUSTER_THRESHOLD) {
                 union(i, j);
             }
         }
@@ -243,11 +311,12 @@ function splitWords(text) {
         .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.
+// Blends hybrid structural/lexical overlap (see hybridScore) 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 structuralScore = hybridScore(memoryContent, task);
     const memoryWords = new Set(splitWords(memoryContent));
     const taskWords = splitWords(task);
     let shared = 0;
@@ -256,6 +325,6 @@ export function scoreMemoryRelevance(memoryContent, task) {
             shared++;
     }
     const wordOverlapRatio = taskWords.length === 0 ? 0 : shared / taskWords.length;
-    return containment * 0.7 + wordOverlapRatio * 0.3;
+    return structuralScore * 0.7 + wordOverlapRatio * 0.3;
 }
 // TODO: optimize the clustering algorithm

package/dist/tools.js

@@ -1 +1,2 @@
+const test = 1;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackmem",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "",
   "main": "index.js",
   "type": "module",