stackmem 1.0.14 → 1.0.16

package/src/cli.ts

@@ -270,6 +270,8 @@ async function cmdStart(project: string) {
   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;
   }
 
@@ -282,11 +284,31 @@ async function cmdStart(project: string) {
 
   const budgetedMemories = applyContextBudget(scoredMemories, CONTEXT_BUDGET_TOKENS);
   const omittedCount = scoredMemories.length - budgetedMemories.length;
-  const tokensUsed = budgetedMemories.reduce(
+  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: { problem: string; solution: string | null }[] = [];
+  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<string, Set<string>>();
 
@@ -323,11 +345,27 @@ async function cmdStart(project: string) {
     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
@@ -1159,6 +1197,27 @@ function writeProjectFile(project: string, resolvedPath: string): void {
   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: string,
+  existingMemories: { id: string; content: string }[],
+  type: MemoryType,
+  content: string
+): Promise<boolean> {
+  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
@@ -1186,16 +1245,7 @@ async function seedMemories(project: string, resolvedPath: string): Promise<numb
       ];
       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 {
       // Malformed package.json — skip the tech-stack memory.
@@ -1212,19 +1262,56 @@ async function seedMemories(project: string, resolvedPath: string): Promise<numb
 
     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) seededCount++;
+      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: string; type: MemoryType; content: string }[] = [
+    { 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/src/index.ts

@@ -92,6 +92,23 @@ server.registerTool(
       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) =>
@@ -112,10 +129,16 @@ server.registerTool(
         ? `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/src/scoring.ts

@@ -5,11 +5,34 @@ const STOP_WORDS = new Set([
   "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: string): string | null {
+  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: string): Set<string> {
+  const packageName = extractDependencyPackageName(text);
+  if (packageName !== null) return new Set([packageName]);
+
   const entities = new Set<string>();
   for (const word of text.toLowerCase().split(/\W+/)) {
     if (word.length < MIN_ENTITY_LENGTH || STOP_WORDS.has(word)) continue;
@@ -33,6 +56,55 @@ export function containmentScore(entitiesA: Set<string>, entitiesB: Set<string>)
   return shared / smallerSize;
 }
 
+function trigramSet(text: string): Set<string> {
+  const normalized = text.toLowerCase();
+  if (normalized.length < 3) {
+    return normalized.length > 0 ? new Set([normalized]) : new Set();
+  }
+
+  const trigrams = new Set<string>();
+  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: string, b: string): number {
+  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: string, b: string): number {
+  const containment = containmentScore(extractEntities(a), extractEntities(b));
+  const overlap = ngramOverlap(a, b);
+  return containment * 0.7 + overlap * 0.3;
+}
+
 // --- memory links ------------------------------------------------------
 
 export interface ExistingMemory {
@@ -52,12 +124,11 @@ export function computeMemoryLinks(
   existingMemories: ExistingMemory[],
   threshold = 0.15
 ): MemoryLink[] {
-  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);
 }
@@ -96,14 +167,17 @@ export function decideSaveAction(
   newContent: string,
   existingMemories: ExistingMemory[]
 ): SaveAction {
-  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: { id: string; score: number } | null = null;
   let bestSupersede: { id: string; score: number } | null = 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) {
@@ -186,11 +260,9 @@ export function clusterMemories(memories: any[]): any[][] {
     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);
       }
     }
@@ -307,11 +379,12 @@ function splitWords(text: string): string[] {
     .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: string, task: string): number {
-  const containment = containmentScore(extractEntities(memoryContent), extractEntities(task));
+  const structuralScore = hybridScore(memoryContent, task);
 
   const memoryWords = new Set(splitWords(memoryContent));
   const taskWords = splitWords(task);
@@ -322,6 +395,6 @@ export function scoreMemoryRelevance(memoryContent: string, task: string): numbe
   }
   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