@teammates/recall 0.1.0

package/src/search.ts

@@ -0,0 +1,107 @@
+import { LocalDocumentIndex } from "vectra";
+import { LocalEmbeddings } from "./embeddings.js";
+import { Indexer } from "./indexer.js";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+
+export interface SearchOptions {
+  /** Path to the .teammates directory */
+  teammatesDir: string;
+  /** Teammate name to search (searches all if omitted) */
+  teammate?: string;
+  /** Max results per teammate (default: 5) */
+  maxResults?: number;
+  /** Max chunks per document (default: 3) */
+  maxChunks?: number;
+  /** Max tokens per section (default: 500) */
+  maxTokens?: number;
+  /** Embedding model name */
+  model?: string;
+  /** Skip auto-sync before searching (default: false) */
+  skipSync?: boolean;
+}
+
+export interface SearchResult {
+  teammate: string;
+  uri: string;
+  text: string;
+  score: number;
+}
+
+/**
+ * Search teammate memories using semantic + keyword search.
+ */
+export async function search(
+  query: string,
+  options: SearchOptions
+): Promise<SearchResult[]> {
+  const indexRoot = path.join(options.teammatesDir, ".index");
+  const embeddings = new LocalEmbeddings(options.model);
+  const maxResults = options.maxResults ?? 5;
+  const maxChunks = options.maxChunks ?? 3;
+  const maxTokens = options.maxTokens ?? 500;
+
+  // Auto-sync: upsert any new/changed files before searching
+  if (!options.skipSync) {
+    const indexer = new Indexer({ teammatesDir: options.teammatesDir, model: options.model });
+    if (options.teammate) {
+      await indexer.syncTeammate(options.teammate);
+    } else {
+      await indexer.syncAll();
+    }
+  }
+
+  // Determine which teammates to search
+  let teammates: string[];
+  if (options.teammate) {
+    teammates = [options.teammate];
+  } else {
+    try {
+      const entries = await fs.readdir(indexRoot, { withFileTypes: true });
+      teammates = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+
+  const allResults: SearchResult[] = [];
+
+  for (const teammate of teammates) {
+    const indexPath = path.join(indexRoot, teammate);
+    try {
+      await fs.access(indexPath);
+    } catch {
+      continue; // No index for this teammate
+    }
+
+    const index = new LocalDocumentIndex({
+      folderPath: indexPath,
+      embeddings,
+    });
+
+    if (!(await index.isIndexCreated())) continue;
+
+    const docs = await index.queryDocuments(query, {
+      maxDocuments: maxResults,
+      maxChunks,
+    });
+
+    for (const doc of docs) {
+      const sections = await doc.renderSections(maxTokens, 1);
+      for (const section of sections) {
+        allResults.push({
+          teammate,
+          uri: doc.uri,
+          text: section.text,
+          score: section.score,
+        });
+      }
+    }
+  }
+
+  // Sort by score descending, return top results
+  allResults.sort((a, b) => b.score - a.score);
+  return allResults.slice(0, maxResults);
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}