@teammates/recall 0.4.1 → 0.5.1

package/src/search.test.ts

@@ -1,49 +1,386 @@
-import { describe, expect, it } from "vitest";
-
-// classifyUri is not exported, so we test it indirectly via a re-implementation
-// or we can import the module and test the search function behavior.
-// Since classifyUri is a pure function, let's extract and test its logic.
-
-describe("classifyUri", () => {
-  // Re-implement the classification logic for unit testing
-  function classifyUri(uri: string): string {
-    if (uri.includes("/memory/weekly/")) return "weekly";
-    if (uri.includes("/memory/monthly/")) return "monthly";
-    const memoryMatch = uri.match(/\/memory\/([^/]+)\.md$/);
-    if (memoryMatch) {
-      const stem = memoryMatch[1];
-      if (/^\d{4}-\d{2}-\d{2}$/.test(stem)) return "daily";
-      return "typed_memory";
-    }
-    return "other";
-  }
-
-  it("classifies weekly summaries", () => {
-    expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
-  });
-
-  it("classifies monthly summaries", () => {
-    expect(classifyUri("beacon/memory/monthly/2025-12.md")).toBe("monthly");
-  });
-
-  it("classifies typed memories", () => {
-    expect(classifyUri("beacon/memory/feedback_testing.md")).toBe(
-      "typed_memory",
-    );
-    expect(classifyUri("beacon/memory/project_goals.md")).toBe("typed_memory");
-  });
-
-  it("classifies daily logs", () => {
-    expect(classifyUri("beacon/memory/2026-03-14.md")).toBe("daily");
-    expect(classifyUri("beacon/memory/2026-01-01.md")).toBe("daily");
-  });
-
-  it("classifies WISDOM.md as other", () => {
-    expect(classifyUri("beacon/WISDOM.md")).toBe("other");
-  });
-
-  it("classifies non-memory paths as other", () => {
-    expect(classifyUri("beacon/SOUL.md")).toBe("other");
-    expect(classifyUri("beacon/notes/todo.md")).toBe("other");
-  });
-});
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Indexer } from "./indexer.js";
+import { classifyUri, multiSearch, search } from "./search.js";
+import type { SearchResult } from "./search.js";
+
+// Deterministic stub embeddings based on text content
+function stubCreateEmbeddings(inputs: string | string[]) {
+  const texts = Array.isArray(inputs) ? inputs : [inputs];
+  return {
+    status: "success" as const,
+    output: texts.map((t) => {
+      const vec = new Array(384).fill(0);
+      for (let i = 0; i < t.length; i++) {
+        vec[i % 384] += t.charCodeAt(i) / 1000;
+      }
+      return vec;
+    }),
+  };
+}
+
+// Mock LocalEmbeddings so search() uses stubs instead of real model
+vi.mock("./embeddings.js", () => ({
+  LocalEmbeddings: class {
+    readonly maxTokens = 256;
+    async createEmbeddings(inputs: string | string[]) {
+      return stubCreateEmbeddings(inputs);
+    }
+  },
+}));
+
+function createIndexer(teammatesDir: string): Indexer {
+  const indexer = new Indexer({ teammatesDir });
+  // Indexer also creates LocalEmbeddings internally — already mocked above
+  return indexer;
+}
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = join(
+    tmpdir(),
+    `recall-search-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await mkdir(testDir, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+describe("classifyUri", () => {
+  it("classifies weekly summaries", () => {
+    expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
+  });
+
+  it("classifies monthly summaries", () => {
+    expect(classifyUri("beacon/memory/monthly/2025-12.md")).toBe("monthly");
+  });
+
+  it("classifies typed memories", () => {
+    expect(classifyUri("beacon/memory/feedback_testing.md")).toBe(
+      "typed_memory",
+    );
+    expect(classifyUri("beacon/memory/project_goals.md")).toBe("typed_memory");
+  });
+
+  it("classifies daily logs", () => {
+    expect(classifyUri("beacon/memory/2026-03-14.md")).toBe("daily");
+    expect(classifyUri("beacon/memory/2026-01-01.md")).toBe("daily");
+  });
+
+  it("classifies WISDOM.md as other", () => {
+    expect(classifyUri("beacon/WISDOM.md")).toBe("other");
+  });
+
+  it("classifies non-memory paths as other", () => {
+    expect(classifyUri("beacon/SOUL.md")).toBe("other");
+    expect(classifyUri("beacon/notes/todo.md")).toBe("other");
+  });
+});
+
+describe("search", () => {
+  it("returns results from an indexed teammate", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom about coding");
+    await writeFile(
+      join(memDir, "feedback_testing.md"),
+      "# Testing feedback\nAlways run tests before committing.",
+    );
+
+    // Pre-build the index with stub embeddings
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    // Patch search to use stub embeddings by searching with skipSync
+    const results = await search("testing feedback", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      model: "stub", // won't matter since we mock at the index level
+    });
+
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].teammate).toBe("beacon");
+    expect(results[0].score).toBeGreaterThan(0);
+  });
+
+  it("returns empty results when no index exists", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+    });
+
+    expect(results).toEqual([]);
+  });
+
+  it("includes recent weekly summaries via recency pass", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W10.md"),
+      "# Week 10\nWorked on search.",
+    );
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nWorked on indexer.",
+    );
+    await writeFile(
+      join(weeklyDir, "2026-W09.md"),
+      "# Week 9\nOld stuff.",
+    );
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+    });
+
+    const uris = results.map((r) => r.uri);
+    // Should include the 2 most recent weeks (W11 and W10), not W09
+    expect(uris).toContain("beacon/memory/weekly/2026-W11.md");
+    expect(uris).toContain("beacon/memory/weekly/2026-W10.md");
+    expect(uris).not.toContain("beacon/memory/weekly/2026-W09.md");
+  });
+
+  it("respects recencyDepth: 0 (no weekly summaries)", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nContent here.",
+    );
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 0,
+    });
+
+    const uris = results.map((r) => r.uri);
+    expect(uris).not.toContain("beacon/memory/weekly/2026-W11.md");
+  });
+
+  it("searches all teammates when no teammate specified", async () => {
+    const beacon = join(testDir, "beacon");
+    const scribe = join(testDir, "scribe");
+    await mkdir(join(beacon, "memory"), { recursive: true });
+    await mkdir(join(scribe, "memory"), { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(scribe, "SOUL.md"), "# Scribe");
+    await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom");
+    await writeFile(join(scribe, "WISDOM.md"), "# Scribe wisdom");
+
+    // Build indexes
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+    await indexer.indexTeammate("scribe");
+
+    const results = await search("wisdom", {
+      teammatesDir: testDir,
+      skipSync: true,
+    });
+
+    const teammates = new Set(results.map((r) => r.teammate));
+    expect(teammates.size).toBeGreaterThanOrEqual(1);
+  });
+
+  it("deduplicates recency results with semantic results", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nSearch implementation details.",
+    );
+
+    // Build index that includes the weekly file
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await search("search implementation", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+    });
+
+    // The weekly file should appear only once despite being picked up by both passes
+    const weeklyUris = results.filter(
+      (r) => r.uri === "beacon/memory/weekly/2026-W11.md",
+    );
+    expect(weeklyUris).toHaveLength(1);
+  });
+
+  it("applies typed memory boost", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Some wisdom about testing");
+    await writeFile(
+      join(memDir, "feedback_testing.md"),
+      "# Testing feedback\nAlways verify test output carefully.",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await search("testing", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      typedMemoryBoost: 1.5,
+    });
+
+    // Find typed memory results — they should have boosted scores
+    const typedResults = results.filter(
+      (r) => r.contentType === "typed_memory",
+    );
+    if (typedResults.length > 0) {
+      // Just verify the contentType was set correctly
+      expect(typedResults[0].contentType).toBe("typed_memory");
+    }
+  });
+});
+
+describe("multiSearch", () => {
+  it("merges results from primary and additional queries", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about architecture");
+    await writeFile(
+      join(memDir, "feedback_code_review.md"),
+      "# Code review feedback\nAlways review pull requests thoroughly.",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await multiSearch("architecture", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      additionalQueries: ["code review"],
+    });
+
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("deduplicates by URI — highest score wins", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(beacon, "WISDOM.md"),
+      "# Wisdom about testing and code quality",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await multiSearch("testing", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      additionalQueries: ["testing code quality"],
+    });
+
+    // Check no duplicate URIs
+    const uris = results.map((r) => r.uri);
+    const uniqueUris = new Set(uris);
+    expect(uris.length).toBe(uniqueUris.size);
+  });
+
+  it("merges catalog matches into results", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Wisdom");
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const catalogMatches: SearchResult[] = [
+      {
+        teammate: "beacon",
+        uri: "beacon/memory/project_goals.md",
+        text: "# Project Goals\nBuild the best recall system.",
+        score: 0.92,
+        contentType: "typed_memory",
+      },
+    ];
+
+    const results = await multiSearch("goals", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      catalogMatches,
+    });
+
+    const goalResult = results.find(
+      (r) => r.uri === "beacon/memory/project_goals.md",
+    );
+    expect(goalResult).toBeDefined();
+    expect(goalResult!.score).toBe(0.92);
+  });
+
+  it("additional queries skip recency pass (recencyDepth: 0)", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nDid some work.",
+    );
+
+    const results = await multiSearch("work", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+      additionalQueries: ["more work"],
+    });
+
+    // Weekly should appear at most once (from primary, not duplicated from additional)
+    const weeklyResults = results.filter(
+      (r) => r.uri === "beacon/memory/weekly/2026-W11.md",
+    );
+    expect(weeklyResults.length).toBeLessThanOrEqual(1);
+  });
+
+  it("returns empty when no index and no catalog matches", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+
+    const results = await multiSearch("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+    });
+
+    expect(results).toEqual([]);
+  });
+});

package/src/search.ts

@@ -25,6 +25,14 @@ export interface SearchOptions {
   typedMemoryBoost?: number;
 }
 
+/** Options for multi-query search with deduplication. */
+export interface MultiSearchOptions extends SearchOptions {
+  /** Additional queries beyond the primary (keyword-focused, conversation-derived, etc.) */
+  additionalQueries?: string[];
+  /** Pre-matched memory catalog results to merge into the final set */
+  catalogMatches?: SearchResult[];
+}
+
 export interface SearchResult {
   teammate: string;
   uri: string;
@@ -37,7 +45,7 @@ export interface SearchResult {
 /**
  * Classify a URI into a content type for priority scoring.
  */
-function classifyUri(uri: string): string {
+export function classifyUri(uri: string): string {
   if (uri.includes("/memory/weekly/")) return "weekly";
   if (uri.includes("/memory/monthly/")) return "monthly";
   // Typed memories are in memory/ but not daily logs (YYYY-MM-DD) and not in subdirs
@@ -176,3 +184,61 @@ export async function search(
   allResults.sort((a, b) => b.score - a.score);
   return allResults.slice(0, maxResults + recencyDepth); // allow extra slots for recency results
 }
+
+/**
+ * Multi-query search with deduplication and catalog merge.
+ *
+ * Fires the primary query plus any additional queries (keyword-focused,
+ * conversation-derived) and merges results. Catalog matches (from frontmatter
+ * text matching) are also merged. Deduplication is by URI — when the same
+ * URI appears from multiple queries, the highest score wins.
+ */
+export async function multiSearch(
+  primaryQuery: string,
+  options: MultiSearchOptions,
+): Promise<SearchResult[]> {
+  const additionalQueries = options.additionalQueries ?? [];
+  const catalogMatches = options.catalogMatches ?? [];
+  const maxResults = options.maxResults ?? 5;
+  const recencyDepth = options.recencyDepth ?? 2;
+
+  // Fire all queries — primary gets full treatment (recency pass + semantic)
+  // Additional queries get semantic only (skipRecency to avoid duplicate weeklies)
+  const primaryResults = await search(primaryQuery, options);
+
+  // Collect all results keyed by URI, keeping highest score
+  const bestByUri = new Map<string, SearchResult>();
+  for (const r of primaryResults) {
+    const existing = bestByUri.get(r.uri);
+    if (!existing || r.score > existing.score) {
+      bestByUri.set(r.uri, r);
+    }
+  }
+
+  // Fire additional queries (reuse same search options minus recency to avoid dupes)
+  for (const query of additionalQueries) {
+    const results = await search(query, {
+      ...options,
+      recencyDepth: 0, // primary already got the weekly summaries
+    });
+    for (const r of results) {
+      const existing = bestByUri.get(r.uri);
+      if (!existing || r.score > existing.score) {
+        bestByUri.set(r.uri, r);
+      }
+    }
+  }
+
+  // Merge catalog matches (frontmatter text-matched results)
+  for (const r of catalogMatches) {
+    const existing = bestByUri.get(r.uri);
+    if (!existing || r.score > existing.score) {
+      bestByUri.set(r.uri, r);
+    }
+  }
+
+  // Sort by score descending, return top results
+  const merged = [...bestByUri.values()];
+  merged.sort((a, b) => b.score - a.score);
+  return merged.slice(0, maxResults + recencyDepth);
+}