fix the learning

apps/web/src/lib/services/memory-extraction.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { MemoryCategory, MemorySourceType } from "@adventureos/shared";
-import { SENSITIVE_MEMORY_CATEGORIES } from "@adventureos/shared";
+import { MEMORY_CATEGORIES, SENSITIVE_MEMORY_CATEGORIES } from "@adventureos/shared";
 import { parseAiJson } from "@/lib/ai/parse-json";
 import { getAiBehaviorConfig, getAiProviderConfig, generateTextWithFallback, buildSystemPrompt } from "./ai-config";
 import { createSuggestion, getMemoryLearningSettings } from "./ai-memory";
@@ -19,6 +19,111 @@ const candidateSchema = z.object({
     .max(2),
 });
 
+export type MemorySuggestionCandidate = {
+  category: MemoryCategory;
+  title: string;
+  content: string;
+  confidence: number;
+};
+
+type PatternRule = {
+  category: MemoryCategory;
+  confidence: number;
+  patterns: RegExp[];
+  titlePrefix?: string;
+  content: (value: string) => string;
+};
+
+const FILLER_PREFIX = /^(?:that\s+|to\s+|i\s+|i'm\s+|i am\s+|my\s+)/i;
+
+const RULES: PatternRule[] = [
+  {
+    category: "current_goals",
+    confidence: 0.9,
+    patterns: [
+      /^(?:one of my goals|my current goal|my goal|a goal of mine)(?:\s+for\s+.+?)?\s+is\s+(.+)$/i,
+      /^i want to\s+(.+)$/i,
+      /^i'm trying to\s+(.+)$/i,
+      /^i am trying to\s+(.+)$/i,
+      /^i want to be more\s+(.+)$/i,
+      /^my current focus is\s+(.+)$/i,
+    ],
+    content: (value) => `One of the user's current goals is to ${ensureVerbPhrase(value)}.`,
+  },
+  {
+    category: "likes",
+    confidence: 0.85,
+    patterns: [/^i like\s+(.+)$/i],
+    content: (value) => `The user likes ${lowerFirst(value)}.`,
+  },
+  {
+    category: "dislikes",
+    confidence: 0.85,
+    patterns: [/^i dislike\s+(.+)$/i, /^i don't like\s+(.+)$/i, /^i do not like\s+(.+)$/i],
+    content: (value) => `The user dislikes ${lowerFirst(value)}.`,
+  },
+  {
+    category: "ai_tone",
+    confidence: 0.9,
+    patterns: [/^i prefer\s+(short explanations|direct explanations|concise explanations|brief explanations|.+\s+explanations)$/i, /^i want the ai to\s+(.+)$/i],
+    content: (value) =>
+      /\bexplanations\b/i.test(value)
+        ? `The user prefers ${lowerFirst(value)}.`
+        : `The user wants the AI to ${ensureVerbPhrase(value)}.`,
+  },
+  {
+    category: "worries",
+    confidence: 0.8,
+    patterns: [/^i get worried when\s+(.+)$/i, /^i'm worried about\s+(.+)$/i, /^i am worried about\s+(.+)$/i],
+    content: (value) => `The user has a worry or concern about ${lowerFirst(value)}.`,
+  },
+  {
+    category: "personal_context",
+    confidence: 0.75,
+    patterns: [/^i struggle with\s+(.+)$/i, /^i need help with\s+(.+)$/i],
+    content: (value) => `The user needs support with ${lowerFirst(value)}.`,
+  },
+  {
+    category: "personal_context",
+    confidence: 0.95,
+    patterns: [/^(?:remember that|save this:?|add this to memory:?)(.+)$/i],
+    titlePrefix: "Remember",
+    content: (value) => `The user explicitly asked the app to remember that ${stripTrailingPunctuation(value)}.`,
+  },
+];
+
+const LEARNING_HINTS = /\b(learn|learning|examples?|explanations?|teach|lesson)\b/i;
+const EXERCISE_HINTS = /\b(exercise|work out|workout|run|gym|walk|train)\b/i;
+const UNSPECIFIC_MESSAGES = /^(hello|hi|hey|thanks|thank you|what can you do\??|that's interesting|that is interesting)$/i;
+
+export function extractDeterministicMemoryCandidates(sourceText: string): MemorySuggestionCandidate[] {
+  const normalized = normalizeInput(sourceText);
+  if (!normalized || normalized.length < 8 || UNSPECIFIC_MESSAGES.test(normalized)) return [];
+
+  for (const rule of RULES) {
+    for (const pattern of rule.patterns) {
+      const match = normalized.match(pattern);
+      const rawValue = match?.[1]?.trim();
+      if (!rawValue) continue;
+
+      const value = cleanValue(rawValue);
+      if (!isDurableEnough(value)) return [];
+
+      const category = refineCategory(rule.category, normalized, value);
+      return [
+        {
+          category,
+          title: buildTitle(value, rule.titlePrefix),
+          content: refineContent(rule.content(value), normalized),
+          confidence: rule.confidence,
+        },
+      ];
+    }
+  }
+
+  return [];
+}
+
 export async function extractMemoryCandidates(
   userId: string,
   sourceType: MemorySourceType,
@@ -26,18 +131,52 @@ export async function extractMemoryCandidates(
   sourceRef?: { type: string; id?: string; date?: string }
 ) {
   const settings = await getMemoryLearningSettings(userId);
-  if (!settings.learningEnabled || !settings.autoSuggestEnabled) return [];
+  if (
+    !settings.learningEnabled ||
+    !settings.autoSuggestEnabled ||
+    (sourceType === "chat" && !settings.suggestAfterChat)
+  ) {
+    return [];
+  }
 
-  const behavior = await getAiBehaviorConfig(userId);
-  const providerConfig = await getAiProviderConfig(userId);
-  if (!behavior.enabled || !providerConfig.enabled) return [];
+  const results = [];
+  const deterministic = extractDeterministicMemoryCandidates(sourceText);
+  for (const c of deterministic) {
+    if (!settings.allowedCategories.includes(c.category)) continue;
+    if (
+      SENSITIVE_MEMORY_CATEGORIES.includes(c.category) &&
+      !settings.allowSensitiveCategories
+    ) {
+      continue;
+    }
+    const row = await createSuggestion(userId, {
+      category: c.category,
+      title: c.title,
+      content: c.content,
+      sourceType,
+      sourceRef,
+      confidence: c.confidence,
+    });
+    if (row) results.push(row);
+  }
+
+  let behavior: Awaited<ReturnType<typeof getAiBehaviorConfig>>;
+  let providerConfig: Awaited<ReturnType<typeof getAiProviderConfig>>;
+  try {
+    behavior = await getAiBehaviorConfig(userId);
+    providerConfig = await getAiProviderConfig(userId);
+  } catch {
+    return results;
+  }
+  if (!behavior.enabled || !providerConfig.enabled) return results;
 
   const prompt = `From this user text, suggest 0-2 personal memory facts the app could remember (only clear patterns, not guesses).
 User text:
 """
 ${sourceText.slice(0, 1500)}
 """
-Return JSON: { "candidates": [{ "category": "likes|motivators|current_goals|reading_preferences|learning_interests|worries|...", "title": "short label", "content": "one sentence fact", "confidence": 0.0-1.0, "sensitivity": "normal|private|sensitive" }] }
+Use only these categories: ${Object.keys(MEMORY_CATEGORIES).join(", ")}.
+Return JSON: { "candidates": [{ "category": "likes|motivators|current_goals|reading_preferences|learning_interests|worries|...", "title": "short label", "content": "one sentence fact about the user", "confidence": 0.0-1.0, "sensitivity": "normal|private|sensitive" }] }
 If nothing clear, return { "candidates": [] }.`;
 
   try {
@@ -57,9 +196,8 @@ If nothing clear, return { "candidates": [] }.`;
     );
 
     const parsed = candidateSchema.safeParse(parseAiJson(res.text));
-    if (!parsed.success) return [];
+    if (!parsed.success) return results;
 
-    const results = [];
     for (const c of parsed.data.candidates) {
       if (c.confidence < 0.6) continue;
       if (!settings.allowedCategories.includes(c.category as MemoryCategory)) continue;
@@ -81,7 +219,7 @@ If nothing clear, return { "candidates": [] }.`;
     }
     return results;
   } catch {
-    return [];
+    return results;
   }
 }
 
@@ -89,3 +227,68 @@ async function getTemplateBody(userId: string) {
   const { getTemplateBody: getTpl } = await import("./ai-templates");
   return getTpl(userId, "system_core");
 }
+
+function normalizeInput(value: string): string {
+  return value.trim().replace(/[’‘]/g, "'").replace(/\s+/g, " ");
+}
+
+function cleanValue(value: string): string {
+  return stripTrailingPunctuation(value.replace(FILLER_PREFIX, "").trim());
+}
+
+function stripTrailingPunctuation(value: string): string {
+  return value.trim().replace(/[.!?]+$/g, "").trim();
+}
+
+function isDurableEnough(value: string): boolean {
+  const lower = value.toLowerCase();
+  if (value.length < 4) return false;
+  if (/^(this|that|it|stuff|things|more|better)$/i.test(lower)) return false;
+  return true;
+}
+
+function refineCategory(category: MemoryCategory, fullText: string, value: string): MemoryCategory {
+  const combined = `${fullText} ${value}`;
+  if (category === "likes" && LEARNING_HINTS.test(combined)) return "learning_interests";
+  if (category === "current_goals" && EXERCISE_HINTS.test(combined)) return "exercise_preferences";
+  return category;
+}
+
+function refineContent(content: string, fullText: string): string {
+  if (/one of my goals/i.test(fullText) && /next coming weeks|next few weeks/i.test(fullText)) {
+    return content.replace("current goals is to", "goals for the next few weeks is to");
+  }
+  return content;
+}
+
+function ensureVerbPhrase(value: string): string {
+  const cleaned = lowerFirst(stripTrailingPunctuation(value));
+  if (/^(be|build|wake|read|exercise|work|study|learn|sleep|get|start|stop|finish|practice|focus)\b/i.test(cleaned)) {
+    return cleaned;
+  }
+  return cleaned;
+}
+
+function lowerFirst(value: string): string {
+  return value.charAt(0).toLowerCase() + value.slice(1);
+}
+
+function buildTitle(value: string, prefix?: string): string {
+  const clean = stripTrailingPunctuation(value)
+    .replace(/\b7\s*a\.?\s*m\.?\b/gi, "7am")
+    .replace(/\s+/g, " ")
+    .trim();
+  const title = clean
+    .replace(/^(?:to\s+)/i, "")
+    .split(" ")
+    .slice(0, 8)
+    .map((word, index) => {
+      if (/^\d/.test(word)) return word;
+      if (index > 0 && /^(at|to|with|for|and|or|the|a|an|of)$/i.test(word)) {
+        return word.toLowerCase();
+      }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join(" ");
+  return prefix ? `${prefix}: ${title}` : title;
+}