feat: 记忆系统的实现

Author: claude-code-best

scripts/dev.ts

@@ -15,7 +15,7 @@ const defineArgs = Object.entries(defines).flatMap(([k, v]) => [
 
 // Bun --feature flags: enable feature() gates at runtime.
 // Default features enabled in dev mode.
-const DEFAULT_FEATURES = ["BUDDY", "TRANSCRIPT_CLASSIFIER", "BRIDGE_MODE", "AGENT_TRIGGERS_REMOTE", "CHICAGO_MCP", "VOICE_MODE"];
+const DEFAULT_FEATURES = ["BUDDY", "TRANSCRIPT_CLASSIFIER", "BRIDGE_MODE", "AGENT_TRIGGERS_REMOTE", "CHICAGO_MCP", "VOICE_MODE", "EXTRACT_MEMORIES", "TEAMMEM"];
 
 // Any env var matching FEATURE_<NAME>=1 will also enable that feature.
 // e.g. FEATURE_PROACTIVE=1 bun run dev

src/memdir/__tests__/findRelevantMemories.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for findRelevantMemories helper logic.
+ * The main function (findRelevantMemories) depends on sideQuery (API call)
+ * and scanMemoryFiles (filesystem), so we test the pure filtering/selection
+ * logic that doesn't require mocking the API layer.
+ */
+import { describe, expect, test } from "bun:test"
+import type { MemoryHeader } from "../memoryScan"
+
+describe("findRelevantMemories logic", () => {
+  describe("alreadySurfaced filtering", () => {
+    test("filters out already surfaced files", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "a.md",
+          filePath: "/mem/a.md",
+          mtimeMs: 1000,
+          description: "Memory A",
+          type: "user",
+        },
+        {
+          filename: "b.md",
+          filePath: "/mem/b.md",
+          mtimeMs: 2000,
+          description: "Memory B",
+          type: "project",
+        },
+        {
+          filename: "c.md",
+          filePath: "/mem/c.md",
+          mtimeMs: 3000,
+          description: "Memory C",
+          type: "feedback",
+        },
+      ]
+      const alreadySurfaced = new Set(["/mem/a.md"])
+      const filtered = memories.filter(m => !alreadySurfaced.has(m.filePath))
+      expect(filtered).toHaveLength(2)
+      expect(filtered.map(m => m.filename)).toEqual(["b.md", "c.md"])
+    })
+
+    test("returns all when nothing is already surfaced", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "a.md",
+          filePath: "/mem/a.md",
+          mtimeMs: 1000,
+          description: "A",
+          type: "user",
+        },
+      ]
+      const alreadySurfaced = new Set<string>()
+      const filtered = memories.filter(m => !alreadySurfaced.has(m.filePath))
+      expect(filtered).toHaveLength(1)
+    })
+
+    test("returns empty when all are already surfaced", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "a.md",
+          filePath: "/mem/a.md",
+          mtimeMs: 1000,
+          description: "A",
+          type: "user",
+        },
+      ]
+      const alreadySurfaced = new Set(["/mem/a.md"])
+      const filtered = memories.filter(m => !alreadySurfaced.has(m.filePath))
+      expect(filtered).toHaveLength(0)
+    })
+  })
+
+  describe("filename validation against memory list", () => {
+    test("filters selected filenames against valid set", () => {
+      const validFilenames = new Set(["a.md", "b.md", "c.md"])
+      const selected = ["a.md", "x.md", "b.md", "y.md"]
+      const filtered = selected.filter(f => validFilenames.has(f))
+      expect(filtered).toEqual(["a.md", "b.md"])
+    })
+
+    test("returns empty when no selected filenames are valid", () => {
+      const validFilenames = new Set(["a.md", "b.md"])
+      const selected = ["x.md", "y.md"]
+      const filtered = selected.filter(f => validFilenames.has(f))
+      expect(filtered).toEqual([])
+    })
+  })
+
+  describe("selected filename to header resolution", () => {
+    test("resolves selected filenames to headers", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "a.md",
+          filePath: "/mem/a.md",
+          mtimeMs: 1000,
+          description: "A",
+          type: "user",
+        },
+        {
+          filename: "b.md",
+          filePath: "/mem/b.md",
+          mtimeMs: 2000,
+          description: "B",
+          type: "project",
+        },
+      ]
+      const byFilename = new Map(memories.map(m => [m.filename, m]))
+      const selectedFilenames = ["b.md", "a.md"]
+      const resolved = selectedFilenames
+        .map(filename => byFilename.get(filename))
+        .filter((m): m is MemoryHeader => m !== undefined)
+      expect(resolved).toHaveLength(2)
+      expect(resolved[0].filename).toBe("b.md")
+      expect(resolved[1].filename).toBe("a.md")
+    })
+
+    test("skips unresolved filenames", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "a.md",
+          filePath: "/mem/a.md",
+          mtimeMs: 1000,
+          description: "A",
+          type: "user",
+        },
+      ]
+      const byFilename = new Map(memories.map(m => [m.filename, m]))
+      const selectedFilenames = ["a.md", "nonexistent.md"]
+      const resolved = selectedFilenames
+        .map(filename => byFilename.get(filename))
+        .filter((m): m is MemoryHeader => m !== undefined)
+      expect(resolved).toHaveLength(1)
+      expect(resolved[0].filename).toBe("a.md")
+    })
+  })
+
+  describe("RelevantMemory output mapping", () => {
+    test("maps MemoryHeader to RelevantMemory", () => {
+      const memories: MemoryHeader[] = [
+        {
+          filename: "test.md",
+          filePath: "/mem/test.md",
+          mtimeMs: 5000,
+          description: "Test",
+          type: "feedback",
+        },
+      ]
+      const result = memories.map(m => ({
+        path: m.filePath,
+        mtimeMs: m.mtimeMs,
+      }))
+      expect(result).toEqual([{ path: "/mem/test.md", mtimeMs: 5000 }])
+    })
+  })
+})

src/memdir/__tests__/memdir.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from "bun:test"
+import {
+  truncateEntrypointContent,
+  MAX_ENTRYPOINT_LINES,
+  MAX_ENTRYPOINT_BYTES,
+  ENTRYPOINT_NAME,
+  buildMemoryLines,
+} from "../memdir"
+
+describe("truncateEntrypointContent", () => {
+  test("returns content unchanged when within limits", () => {
+    const content = "line1\nline2\nline3"
+    const result = truncateEntrypointContent(content)
+    expect(result.content).toBe(content)
+    expect(result.wasLineTruncated).toBe(false)
+    expect(result.wasByteTruncated).toBe(false)
+    expect(result.lineCount).toBe(3)
+  })
+
+  test("handles empty content", () => {
+    const result = truncateEntrypointContent("")
+    expect(result.content).toBe("")
+    expect(result.wasLineTruncated).toBe(false)
+    expect(result.lineCount).toBe(1) // empty string splits to [""]
+  })
+
+  test("truncates by line count when exceeding MAX_ENTRYPOINT_LINES", () => {
+    const lines = Array.from({ length: MAX_ENTRYPOINT_LINES + 50 }, (_, i) => `line ${i}`)
+    const content = lines.join("\n")
+    const result = truncateEntrypointContent(content)
+    expect(result.wasLineTruncated).toBe(true)
+    expect(result.wasByteTruncated).toBe(false)
+    // Content should contain the warning
+    expect(result.content).toContain("WARNING")
+    expect(result.content).toContain(ENTRYPOINT_NAME)
+    // First MAX_ENTRYPOINT_LINES lines should be preserved
+    const resultLines = result.content.split("\n")
+    expect(resultLines[0]).toBe("line 0")
+  })
+
+  test("truncates by byte count when exceeding MAX_ENTRYPOINT_BYTES", () => {
+    // Create content with few lines but huge size
+    const hugeLine = "x".repeat(MAX_ENTRYPOINT_BYTES + 1000)
+    const content = `header\n${hugeLine}`
+    const result = truncateEntrypointContent(content)
+    expect(result.wasByteTruncated).toBe(true)
+    expect(result.content).toContain("WARNING")
+    expect(result.content.length).toBeLessThan(content.length)
+  })
+
+  test("truncates both when exceeding both limits", () => {
+    const lines = Array.from(
+      { length: MAX_ENTRYPOINT_LINES + 10 },
+      () => "x".repeat(200),
+    )
+    const content = lines.join("\n")
+    const result = truncateEntrypointContent(content)
+    expect(result.wasLineTruncated).toBe(true)
+    expect(result.wasByteTruncated).toBe(true)
+  })
+
+  test("trims whitespace from input", () => {
+    const content = "  line1\nline2\n  "
+    const result = truncateEntrypointContent(content)
+    expect(result.content).toBe("line1\nline2")
+  })
+})
+
+describe("buildMemoryLines", () => {
+  test("returns non-empty array", () => {
+    const lines = buildMemoryLines("test memory", "/tmp/mem")
+    expect(lines.length).toBeGreaterThan(0)
+  })
+
+  test("starts with the display name as heading", () => {
+    const lines = buildMemoryLines("my memory", "/tmp/mem")
+    expect(lines[0]).toBe("# my memory")
+  })
+
+  test("includes the memory directory path", () => {
+    const lines = buildMemoryLines("test", "/custom/path/memory/")
+    const joined = lines.join("\n")
+    expect(joined).toContain("/custom/path/memory/")
+  })
+
+  test("includes MEMORY.md as entrypoint name", () => {
+    const lines = buildMemoryLines("test", "/tmp/mem")
+    const joined = lines.join("\n")
+    expect(joined).toContain("MEMORY.md")
+  })
+
+  test("includes type taxonomy", () => {
+    const lines = buildMemoryLines("test", "/tmp/mem")
+    const joined = lines.join("\n")
+    expect(joined).toContain("user")
+    expect(joined).toContain("feedback")
+    expect(joined).toContain("project")
+    expect(joined).toContain("reference")
+  })
+
+  test("includes How to save section with index when skipIndex=false", () => {
+    const lines = buildMemoryLines("test", "/tmp/mem", undefined, false)
+    const joined = lines.join("\n")
+    expect(joined).toContain("How to save memories")
+    expect(joined).toContain("Step 2")
+  })
+
+  test("skips Step 2 index instructions when skipIndex=true", () => {
+    const lines = buildMemoryLines("test", "/tmp/mem", undefined, true)
+    const joined = lines.join("\n")
+    expect(joined).toContain("How to save memories")
+    expect(joined).not.toContain("Step 2")
+  })
+
+  test("includes extra guidelines", () => {
+    const guidelines = ["Custom rule 1", "Custom rule 2"]
+    const lines = buildMemoryLines("test", "/tmp/mem", guidelines)
+    const joined = lines.join("\n")
+    expect(joined).toContain("Custom rule 1")
+    expect(joined).toContain("Custom rule 2")
+  })
+})

src/memdir/__tests__/memoryAge.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test"
+import {
+  memoryAgeDays,
+  memoryAge,
+  memoryFreshnessText,
+  memoryFreshnessNote,
+} from "../memoryAge"
+
+describe("memoryAgeDays", () => {
+  test("returns 0 for current timestamp", () => {
+    expect(memoryAgeDays(Date.now())).toBe(0)
+  })
+
+  test("returns 0 for very recent timestamp (1 second ago)", () => {
+    expect(memoryAgeDays(Date.now() - 1000)).toBe(0)
+  })
+
+  test("returns 1 for yesterday (24 hours ago)", () => {
+    expect(memoryAgeDays(Date.now() - 86_400_000)).toBe(1)
+  })
+
+  test("returns 7 for a week ago", () => {
+    expect(memoryAgeDays(Date.now() - 7 * 86_400_000)).toBe(7)
+  })
+
+  test("returns 30 for a month ago", () => {
+    expect(memoryAgeDays(Date.now() - 30 * 86_400_000)).toBe(30)
+  })
+
+  test("clamps negative (future mtime) to 0", () => {
+    expect(memoryAgeDays(Date.now() + 86_400_000)).toBe(0)
+  })
+
+  test("floor rounds partial days", () => {
+    // 1.5 days ago
+    expect(memoryAgeDays(Date.now() - 1.5 * 86_400_000)).toBe(1)
+  })
+})
+
+describe("memoryAge", () => {
+  test("returns 'today' for current timestamp", () => {
+    expect(memoryAge(Date.now())).toBe("today")
+  })
+
+  test("returns 'yesterday' for 1 day ago", () => {
+    expect(memoryAge(Date.now() - 86_400_000)).toBe("yesterday")
+  })
+
+  test("returns 'N days ago' for older", () => {
+    expect(memoryAge(Date.now() - 2 * 86_400_000)).toBe("2 days ago")
+    expect(memoryAge(Date.now() - 47 * 86_400_000)).toBe("47 days ago")
+  })
+})
+
+describe("memoryFreshnessText", () => {
+  test("returns empty string for today", () => {
+    expect(memoryFreshnessText(Date.now())).toBe("")
+  })
+
+  test("returns empty string for yesterday", () => {
+    expect(memoryFreshnessText(Date.now() - 86_400_000)).toBe("")
+  })
+
+  test("returns staleness warning for 2+ days", () => {
+    const text = memoryFreshnessText(Date.now() - 2 * 86_400_000)
+    expect(text).toContain("2 days old")
+    expect(text).toContain("point-in-time")
+    expect(text).toContain("Verify against current code")
+  })
+
+  test("includes age in days", () => {
+    const text = memoryFreshnessText(Date.now() - 30 * 86_400_000)
+    expect(text).toContain("30 days old")
+  })
+})
+
+describe("memoryFreshnessNote", () => {
+  test("returns empty string for fresh memory", () => {
+    expect(memoryFreshnessNote(Date.now())).toBe("")
+  })
+
+  test("wraps stale warning in system-reminder tags", () => {
+    const note = memoryFreshnessNote(Date.now() - 5 * 86_400_000)
+    expect(note).toMatch(/^<system-reminder>/)
+    expect(note).toMatch(/<\/system-reminder>\n$/)
+    expect(note).toContain("5 days old")
+  })
+})