@teammates/recall 0.3.1 → 0.3.3

package/src/indexer.ts

@@ -1,237 +1,237 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { LocalDocumentIndex } from "vectra";
-import { LocalEmbeddings } from "./embeddings.js";
-
-export interface IndexerConfig {
-  /** Path to the .teammates directory */
-  teammatesDir: string;
-  /** Embedding model name (default: Xenova/all-MiniLM-L6-v2) */
-  model?: string;
-}
-
-interface TeammateFiles {
-  teammate: string;
-  files: { uri: string; absolutePath: string }[];
-}
-
-/**
- * Indexes teammate memory files (WISDOM.md + memory/*.md) into Vectra.
- * One index per teammate, stored at .teammates/<name>/.index/
- */
-export class Indexer {
-  private _config: IndexerConfig;
-  private _embeddings: LocalEmbeddings;
-
-  constructor(config: IndexerConfig) {
-    this._config = config;
-    this._embeddings = new LocalEmbeddings(config.model);
-  }
-
-  /** Get the index path for a specific teammate */
-  indexPath(teammate: string): string {
-    return path.join(this._config.teammatesDir, teammate, ".index");
-  }
-
-  /**
-   * Discover all teammate directories (folders containing SOUL.md).
-   */
-  async discoverTeammates(): Promise<string[]> {
-    const entries = await fs.readdir(this._config.teammatesDir, {
-      withFileTypes: true,
-    });
-    const teammates: string[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const soulPath = path.join(
-        this._config.teammatesDir,
-        entry.name,
-        "SOUL.md",
-      );
-      try {
-        await fs.access(soulPath);
-        teammates.push(entry.name);
-      } catch {
-        // Not a teammate folder
-      }
-    }
-    return teammates;
-  }
-
-  /**
-   * Collect all indexable memory files for a teammate.
-   */
-  async collectFiles(teammate: string): Promise<TeammateFiles> {
-    const teammateDir = path.join(this._config.teammatesDir, teammate);
-    const files: TeammateFiles["files"] = [];
-
-    // WISDOM.md
-    const wisdomPath = path.join(teammateDir, "WISDOM.md");
-    try {
-      await fs.access(wisdomPath);
-      files.push({ uri: `${teammate}/WISDOM.md`, absolutePath: wisdomPath });
-    } catch {
-      // No WISDOM.md
-    }
-
-    // memory/*.md — typed memories only (skip raw daily logs, they're in prompt context)
-    const memoryDir = path.join(teammateDir, "memory");
-    try {
-      const memoryEntries = await fs.readdir(memoryDir);
-      for (const entry of memoryEntries) {
-        if (!entry.endsWith(".md")) continue;
-        const stem = path.basename(entry, ".md");
-        // Skip daily logs (YYYY-MM-DD) — they're already in prompt context
-        if (/^\d{4}-\d{2}-\d{2}$/.test(stem)) continue;
-        files.push({
-          uri: `${teammate}/memory/${entry}`,
-          absolutePath: path.join(memoryDir, entry),
-        });
-      }
-    } catch {
-      // No memory/ directory
-    }
-
-    // memory/weekly/*.md — weekly summaries (primary episodic search surface)
-    const weeklyDir = path.join(memoryDir, "weekly");
-    try {
-      const weeklyEntries = await fs.readdir(weeklyDir);
-      for (const entry of weeklyEntries) {
-        if (!entry.endsWith(".md")) continue;
-        files.push({
-          uri: `${teammate}/memory/weekly/${entry}`,
-          absolutePath: path.join(weeklyDir, entry),
-        });
-      }
-    } catch {
-      // No weekly/ directory
-    }
-
-    // memory/monthly/*.md — monthly summaries (long-term episodic context)
-    const monthlyDir = path.join(memoryDir, "monthly");
-    try {
-      const monthlyEntries = await fs.readdir(monthlyDir);
-      for (const entry of monthlyEntries) {
-        if (!entry.endsWith(".md")) continue;
-        files.push({
-          uri: `${teammate}/memory/monthly/${entry}`,
-          absolutePath: path.join(monthlyDir, entry),
-        });
-      }
-    } catch {
-      // No monthly/ directory
-    }
-
-    return { teammate, files };
-  }
-
-  /**
-   * Build or rebuild the index for a single teammate.
-   */
-  async indexTeammate(teammate: string): Promise<number> {
-    const { files } = await this.collectFiles(teammate);
-    if (files.length === 0) return 0;
-
-    const indexPath = this.indexPath(teammate);
-    const index = new LocalDocumentIndex({
-      folderPath: indexPath,
-      embeddings: this._embeddings,
-    });
-
-    // Recreate index from scratch
-    await index.createIndex({ version: 1, deleteIfExists: true });
-
-    let count = 0;
-    for (const file of files) {
-      const text = await fs.readFile(file.absolutePath, "utf-8");
-      if (text.trim().length === 0) continue;
-      await index.upsertDocument(file.uri, text, "md");
-      count++;
-    }
-
-    return count;
-  }
-
-  /**
-   * Build or rebuild indexes for all teammates.
-   */
-  async indexAll(): Promise<Map<string, number>> {
-    const teammates = await this.discoverTeammates();
-    const results = new Map<string, number>();
-    for (const teammate of teammates) {
-      const count = await this.indexTeammate(teammate);
-      results.set(teammate, count);
-    }
-    return results;
-  }
-
-  /**
-   * Upsert a single file into an existing teammate index.
-   * Creates the index if it doesn't exist yet.
-   */
-  async upsertFile(teammate: string, filePath: string): Promise<void> {
-    const teammateDir = path.join(this._config.teammatesDir, teammate);
-    const absolutePath = path.resolve(filePath);
-    const relativePath = path.relative(teammateDir, absolutePath);
-    const uri = `${teammate}/${relativePath.replace(/\\/g, "/")}`;
-
-    const text = await fs.readFile(absolutePath, "utf-8");
-    if (text.trim().length === 0) return;
-
-    const indexPath = this.indexPath(teammate);
-    const index = new LocalDocumentIndex({
-      folderPath: indexPath,
-      embeddings: this._embeddings,
-    });
-
-    if (!(await index.isIndexCreated())) {
-      await index.createIndex({ version: 1 });
-    }
-
-    await index.upsertDocument(uri, text, "md");
-  }
-
-  /**
-   * Sync a teammate's index with their current memory files.
-   * Upserts new/changed files without a full rebuild.
-   */
-  async syncTeammate(teammate: string): Promise<number> {
-    const { files } = await this.collectFiles(teammate);
-    if (files.length === 0) return 0;
-
-    const indexPath = this.indexPath(teammate);
-    const index = new LocalDocumentIndex({
-      folderPath: indexPath,
-      embeddings: this._embeddings,
-    });
-
-    if (!(await index.isIndexCreated())) {
-      // No index yet — do a full build
-      return this.indexTeammate(teammate);
-    }
-
-    // Upsert all files (Vectra handles dedup internally via URI)
-    let count = 0;
-    for (const file of files) {
-      const text = await fs.readFile(file.absolutePath, "utf-8");
-      if (text.trim().length === 0) continue;
-      await index.upsertDocument(file.uri, text, "md");
-      count++;
-    }
-
-    return count;
-  }
-
-  /**
-   * Sync indexes for all teammates.
-   */
-  async syncAll(): Promise<Map<string, number>> {
-    const teammates = await this.discoverTeammates();
-    const results = new Map<string, number>();
-    for (const teammate of teammates) {
-      const count = await this.syncTeammate(teammate);
-      results.set(teammate, count);
-    }
-    return results;
-  }
-}
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { LocalDocumentIndex } from "vectra";
+import { LocalEmbeddings } from "./embeddings.js";
+
+export interface IndexerConfig {
+  /** Path to the .teammates directory */
+  teammatesDir: string;
+  /** Embedding model name (default: Xenova/all-MiniLM-L6-v2) */
+  model?: string;
+}
+
+interface TeammateFiles {
+  teammate: string;
+  files: { uri: string; absolutePath: string }[];
+}
+
+/**
+ * Indexes teammate memory files (WISDOM.md + memory/*.md) into Vectra.
+ * One index per teammate, stored at .teammates/<name>/.index/
+ */
+export class Indexer {
+  private _config: IndexerConfig;
+  private _embeddings: LocalEmbeddings;
+
+  constructor(config: IndexerConfig) {
+    this._config = config;
+    this._embeddings = new LocalEmbeddings(config.model);
+  }
+
+  /** Get the index path for a specific teammate */
+  indexPath(teammate: string): string {
+    return path.join(this._config.teammatesDir, teammate, ".index");
+  }
+
+  /**
+   * Discover all teammate directories (folders containing SOUL.md).
+   */
+  async discoverTeammates(): Promise<string[]> {
+    const entries = await fs.readdir(this._config.teammatesDir, {
+      withFileTypes: true,
+    });
+    const teammates: string[] = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const soulPath = path.join(
+        this._config.teammatesDir,
+        entry.name,
+        "SOUL.md",
+      );
+      try {
+        await fs.access(soulPath);
+        teammates.push(entry.name);
+      } catch {
+        // Not a teammate folder
+      }
+    }
+    return teammates;
+  }
+
+  /**
+   * Collect all indexable memory files for a teammate.
+   */
+  async collectFiles(teammate: string): Promise<TeammateFiles> {
+    const teammateDir = path.join(this._config.teammatesDir, teammate);
+    const files: TeammateFiles["files"] = [];
+
+    // WISDOM.md
+    const wisdomPath = path.join(teammateDir, "WISDOM.md");
+    try {
+      await fs.access(wisdomPath);
+      files.push({ uri: `${teammate}/WISDOM.md`, absolutePath: wisdomPath });
+    } catch {
+      // No WISDOM.md
+    }
+
+    // memory/*.md — typed memories only (skip raw daily logs, they're in prompt context)
+    const memoryDir = path.join(teammateDir, "memory");
+    try {
+      const memoryEntries = await fs.readdir(memoryDir);
+      for (const entry of memoryEntries) {
+        if (!entry.endsWith(".md")) continue;
+        const stem = path.basename(entry, ".md");
+        // Skip daily logs (YYYY-MM-DD) — they're already in prompt context
+        if (/^\d{4}-\d{2}-\d{2}$/.test(stem)) continue;
+        files.push({
+          uri: `${teammate}/memory/${entry}`,
+          absolutePath: path.join(memoryDir, entry),
+        });
+      }
+    } catch {
+      // No memory/ directory
+    }
+
+    // memory/weekly/*.md — weekly summaries (primary episodic search surface)
+    const weeklyDir = path.join(memoryDir, "weekly");
+    try {
+      const weeklyEntries = await fs.readdir(weeklyDir);
+      for (const entry of weeklyEntries) {
+        if (!entry.endsWith(".md")) continue;
+        files.push({
+          uri: `${teammate}/memory/weekly/${entry}`,
+          absolutePath: path.join(weeklyDir, entry),
+        });
+      }
+    } catch {
+      // No weekly/ directory
+    }
+
+    // memory/monthly/*.md — monthly summaries (long-term episodic context)
+    const monthlyDir = path.join(memoryDir, "monthly");
+    try {
+      const monthlyEntries = await fs.readdir(monthlyDir);
+      for (const entry of monthlyEntries) {
+        if (!entry.endsWith(".md")) continue;
+        files.push({
+          uri: `${teammate}/memory/monthly/${entry}`,
+          absolutePath: path.join(monthlyDir, entry),
+        });
+      }
+    } catch {
+      // No monthly/ directory
+    }
+
+    return { teammate, files };
+  }
+
+  /**
+   * Build or rebuild the index for a single teammate.
+   */
+  async indexTeammate(teammate: string): Promise<number> {
+    const { files } = await this.collectFiles(teammate);
+    if (files.length === 0) return 0;
+
+    const indexPath = this.indexPath(teammate);
+    const index = new LocalDocumentIndex({
+      folderPath: indexPath,
+      embeddings: this._embeddings,
+    });
+
+    // Recreate index from scratch
+    await index.createIndex({ version: 1, deleteIfExists: true });
+
+    let count = 0;
+    for (const file of files) {
+      const text = await fs.readFile(file.absolutePath, "utf-8");
+      if (text.trim().length === 0) continue;
+      await index.upsertDocument(file.uri, text, "md");
+      count++;
+    }
+
+    return count;
+  }
+
+  /**
+   * Build or rebuild indexes for all teammates.
+   */
+  async indexAll(): Promise<Map<string, number>> {
+    const teammates = await this.discoverTeammates();
+    const results = new Map<string, number>();
+    for (const teammate of teammates) {
+      const count = await this.indexTeammate(teammate);
+      results.set(teammate, count);
+    }
+    return results;
+  }
+
+  /**
+   * Upsert a single file into an existing teammate index.
+   * Creates the index if it doesn't exist yet.
+   */
+  async upsertFile(teammate: string, filePath: string): Promise<void> {
+    const teammateDir = path.join(this._config.teammatesDir, teammate);
+    const absolutePath = path.resolve(filePath);
+    const relativePath = path.relative(teammateDir, absolutePath);
+    const uri = `${teammate}/${relativePath.replace(/\\/g, "/")}`;
+
+    const text = await fs.readFile(absolutePath, "utf-8");
+    if (text.trim().length === 0) return;
+
+    const indexPath = this.indexPath(teammate);
+    const index = new LocalDocumentIndex({
+      folderPath: indexPath,
+      embeddings: this._embeddings,
+    });
+
+    if (!(await index.isIndexCreated())) {
+      await index.createIndex({ version: 1 });
+    }
+
+    await index.upsertDocument(uri, text, "md");
+  }
+
+  /**
+   * Sync a teammate's index with their current memory files.
+   * Upserts new/changed files without a full rebuild.
+   */
+  async syncTeammate(teammate: string): Promise<number> {
+    const { files } = await this.collectFiles(teammate);
+    if (files.length === 0) return 0;
+
+    const indexPath = this.indexPath(teammate);
+    const index = new LocalDocumentIndex({
+      folderPath: indexPath,
+      embeddings: this._embeddings,
+    });
+
+    if (!(await index.isIndexCreated())) {
+      // No index yet — do a full build
+      return this.indexTeammate(teammate);
+    }
+
+    // Upsert all files (Vectra handles dedup internally via URI)
+    let count = 0;
+    for (const file of files) {
+      const text = await fs.readFile(file.absolutePath, "utf-8");
+      if (text.trim().length === 0) continue;
+      await index.upsertDocument(file.uri, text, "md");
+      count++;
+    }
+
+    return count;
+  }
+
+  /**
+   * Sync indexes for all teammates.
+   */
+  async syncAll(): Promise<Map<string, number>> {
+    const teammates = await this.discoverTeammates();
+    const results = new Map<string, number>();
+    for (const teammate of teammates) {
+      const count = await this.syncTeammate(teammate);
+      results.set(teammate, count);
+    }
+    return results;
+  }
+}

package/src/search.test.ts

@@ -1,49 +1,49 @@
-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 { 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");
+  });
+});