@teammates/recall 0.1.1 → 0.2.0

package/src/cli.test.ts

@@ -0,0 +1,324 @@
+import { describe, expect, it } from "vitest";
+
+// parseArgs is not exported, so we re-implement the parsing logic for testing.
+// This validates that the arg parsing contract is correct.
+
+interface Args {
+  command: string;
+  query: string;
+  file: string;
+  dir: string;
+  teammate?: string;
+  results: number;
+  maxChunks?: number;
+  maxTokens?: number;
+  recencyDepth?: number;
+  typedMemoryBoost?: number;
+  model?: string;
+  json: boolean;
+  sync: boolean;
+}
+
+function parseArgs(argv: string[]): Args {
+  const args: Args = {
+    command: "",
+    query: "",
+    file: "",
+    dir: "./.teammates",
+    results: 5,
+    json: false,
+    sync: true,
+  };
+
+  let i = 0;
+  while (
+    i < argv.length &&
+    (argv[i].includes("node") ||
+      argv[i].includes("teammates-recall") ||
+      argv[i].endsWith(".js"))
+  ) {
+    i++;
+  }
+
+  if (i < argv.length && !argv[i].startsWith("-")) {
+    args.command = argv[i++];
+  }
+
+  if (
+    args.command === "search" &&
+    i < argv.length &&
+    !argv[i].startsWith("-")
+  ) {
+    args.query = argv[i++];
+  } else if (
+    args.command === "add" &&
+    i < argv.length &&
+    !argv[i].startsWith("-")
+  ) {
+    args.file = argv[i++];
+  }
+
+  while (i < argv.length) {
+    const arg = argv[i++];
+    switch (arg) {
+      case "--dir":
+        args.dir = argv[i++];
+        break;
+      case "--teammate":
+        args.teammate = argv[i++];
+        break;
+      case "--results":
+        args.results = parseInt(argv[i++], 10);
+        break;
+      case "--model":
+        args.model = argv[i++];
+        break;
+      case "--max-chunks":
+        args.maxChunks = parseInt(argv[i++], 10);
+        break;
+      case "--max-tokens":
+        args.maxTokens = parseInt(argv[i++], 10);
+        break;
+      case "--recency-depth":
+        args.recencyDepth = parseInt(argv[i++], 10);
+        break;
+      case "--typed-memory-boost":
+        args.typedMemoryBoost = parseFloat(argv[i++]);
+        break;
+      case "--no-sync":
+        args.sync = false;
+        break;
+      case "--json":
+        args.json = true;
+        break;
+    }
+  }
+
+  return args;
+}
+
+describe("parseArgs", () => {
+  it("parses search command with query", () => {
+    const args = parseArgs(["node", "cli.js", "search", "hello world"]);
+    expect(args.command).toBe("search");
+    expect(args.query).toBe("hello world");
+  });
+
+  it("parses add command with file path", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "add",
+      "memory/foo.md",
+      "--teammate",
+      "beacon",
+    ]);
+    expect(args.command).toBe("add");
+    expect(args.file).toBe("memory/foo.md");
+    expect(args.teammate).toBe("beacon");
+  });
+
+  it("parses index command", () => {
+    const args = parseArgs(["node", "cli.js", "index"]);
+    expect(args.command).toBe("index");
+  });
+
+  it("parses sync command", () => {
+    const args = parseArgs(["node", "cli.js", "sync"]);
+    expect(args.command).toBe("sync");
+  });
+
+  it("parses status command", () => {
+    const args = parseArgs(["node", "cli.js", "status"]);
+    expect(args.command).toBe("status");
+  });
+
+  it("parses watch command", () => {
+    const args = parseArgs(["node", "cli.js", "watch"]);
+    expect(args.command).toBe("watch");
+  });
+
+  it("defaults dir to ./.teammates", () => {
+    const args = parseArgs(["node", "cli.js", "index"]);
+    expect(args.dir).toBe("./.teammates");
+  });
+
+  it("parses --dir flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "index",
+      "--dir",
+      "/path/to/.teammates",
+    ]);
+    expect(args.dir).toBe("/path/to/.teammates");
+  });
+
+  it("parses --teammate flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--teammate",
+      "scribe",
+    ]);
+    expect(args.teammate).toBe("scribe");
+  });
+
+  it("parses --results flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--results",
+      "10",
+    ]);
+    expect(args.results).toBe(10);
+  });
+
+  it("parses --model flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "index",
+      "--model",
+      "custom/model",
+    ]);
+    expect(args.model).toBe("custom/model");
+  });
+
+  it("parses --json flag", () => {
+    const args = parseArgs(["node", "cli.js", "status", "--json"]);
+    expect(args.json).toBe(true);
+  });
+
+  it("defaults json to false", () => {
+    const args = parseArgs(["node", "cli.js", "status"]);
+    expect(args.json).toBe(false);
+  });
+
+  it("parses --no-sync flag", () => {
+    const args = parseArgs(["node", "cli.js", "search", "query", "--no-sync"]);
+    expect(args.sync).toBe(false);
+  });
+
+  it("defaults sync to true", () => {
+    const args = parseArgs(["node", "cli.js", "search", "query"]);
+    expect(args.sync).toBe(true);
+  });
+
+  it("defaults results to 5", () => {
+    const args = parseArgs(["node", "cli.js", "search", "query"]);
+    expect(args.results).toBe(5);
+  });
+
+  it("returns empty command for no args", () => {
+    const args = parseArgs(["node", "cli.js"]);
+    expect(args.command).toBe("");
+  });
+
+  it("handles multiple flags together", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "my query",
+      "--dir",
+      "/tmp/.teammates",
+      "--teammate",
+      "beacon",
+      "--results",
+      "3",
+      "--json",
+      "--no-sync",
+    ]);
+    expect(args.command).toBe("search");
+    expect(args.query).toBe("my query");
+    expect(args.dir).toBe("/tmp/.teammates");
+    expect(args.teammate).toBe("beacon");
+    expect(args.results).toBe(3);
+    expect(args.json).toBe(true);
+    expect(args.sync).toBe(false);
+  });
+
+  it("parses --max-chunks flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--max-chunks",
+      "7",
+    ]);
+    expect(args.maxChunks).toBe(7);
+  });
+
+  it("parses --max-tokens flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--max-tokens",
+      "1000",
+    ]);
+    expect(args.maxTokens).toBe(1000);
+  });
+
+  it("parses --recency-depth flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--recency-depth",
+      "4",
+    ]);
+    expect(args.recencyDepth).toBe(4);
+  });
+
+  it("parses --typed-memory-boost flag", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "query",
+      "--typed-memory-boost",
+      "1.5",
+    ]);
+    expect(args.typedMemoryBoost).toBe(1.5);
+  });
+
+  it("handles multiple new search flags together", () => {
+    const args = parseArgs([
+      "node",
+      "cli.js",
+      "search",
+      "my query",
+      "--max-chunks",
+      "5",
+      "--max-tokens",
+      "800",
+      "--recency-depth",
+      "3",
+      "--typed-memory-boost",
+      "2.0",
+    ]);
+    expect(args.command).toBe("search");
+    expect(args.query).toBe("my query");
+    expect(args.maxChunks).toBe(5);
+    expect(args.maxTokens).toBe(800);
+    expect(args.recencyDepth).toBe(3);
+    expect(args.typedMemoryBoost).toBe(2.0);
+  });
+
+  it("leaves new flags undefined when not provided", () => {
+    const args = parseArgs(["node", "cli.js", "search", "query"]);
+    expect(args.maxChunks).toBeUndefined();
+    expect(args.maxTokens).toBeUndefined();
+    expect(args.recencyDepth).toBeUndefined();
+    expect(args.typedMemoryBoost).toBeUndefined();
+  });
+});

package/src/cli.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import * as path from "node:path";
+import { type FSWatcher, watch as fsWatch } from "node:fs";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { Indexer } from "./indexer.js";
 import { search } from "./search.js";
 
@@ -14,15 +15,20 @@ Usage:
   teammates-recall add     <file> [options]       Add a single file to a teammate's index
   teammates-recall search  <query> [options]      Search teammate memories (auto-syncs)
   teammates-recall status  [options]              Show index status
+  teammates-recall watch   [options]              Watch for changes and auto-sync
 
 Options:
-  --dir <path>         Path to .teammates directory (default: ./.teammates)
-  --teammate <name>    Limit to a specific teammate
-  --results <n>        Max results (default: 5)
-  --model <name>       Embedding model (default: Xenova/all-MiniLM-L6-v2)
-  --no-sync            Skip auto-sync before search
-  --json               Output as JSON
-  --help               Show this help
+  --dir <path>              Path to .teammates directory (default: ./.teammates)
+  --teammate <name>         Limit to a specific teammate
+  --results <n>             Max results (default: 5)
+  --max-chunks <n>          Max chunks per document (default: 3)
+  --max-tokens <n>          Max tokens per section (default: 500)
+  --recency-depth <n>       Number of recent weekly summaries to include (default: 2)
+  --typed-memory-boost <n>  Relevance boost for typed memories (default: 1.2)
+  --model <name>            Embedding model (default: Xenova/all-MiniLM-L6-v2)
+  --no-sync                 Skip auto-sync before search
+  --json                    Output as JSON
+  --help                    Show this help
 `.trim();
 
 interface Args {
@@ -32,6 +38,10 @@ interface Args {
   dir: string;
   teammate?: string;
   results: number;
+  maxChunks?: number;
+  maxTokens?: number;
+  recencyDepth?: number;
+  typedMemoryBoost?: number;
   model?: string;
   json: boolean;
   sync: boolean;
@@ -50,7 +60,12 @@ function parseArgs(argv: string[]): Args {
 
   let i = 0;
   // Skip node and script path
-  while (i < argv.length && (argv[i].includes("node") || argv[i].includes("teammates-recall") || argv[i].endsWith(".js"))) {
+  while (
+    i < argv.length &&
+    (argv[i].includes("node") ||
+      argv[i].includes("teammates-recall") ||
+      argv[i].endsWith(".js"))
+  ) {
     i++;
   }
 
@@ -59,9 +74,17 @@ function parseArgs(argv: string[]): Args {
   }
 
   // For search, next non-flag arg is the query; for add, it's the file path
-  if (args.command === "search" && i < argv.length && !argv[i].startsWith("-")) {
+  if (
+    args.command === "search" &&
+    i < argv.length &&
+    !argv[i].startsWith("-")
+  ) {
     args.query = argv[i++];
-  } else if (args.command === "add" && i < argv.length && !argv[i].startsWith("-")) {
+  } else if (
+    args.command === "add" &&
+    i < argv.length &&
+    !argv[i].startsWith("-")
+  ) {
     args.file = argv[i++];
   }
 
@@ -80,6 +103,18 @@ function parseArgs(argv: string[]): Args {
       case "--model":
         args.model = argv[i++];
         break;
+      case "--max-chunks":
+        args.maxChunks = parseInt(argv[i++], 10);
+        break;
+      case "--max-tokens":
+        args.maxTokens = parseInt(argv[i++], 10);
+        break;
+      case "--recency-depth":
+        args.recencyDepth = parseInt(argv[i++], 10);
+        break;
+      case "--typed-memory-boost":
+        args.typedMemoryBoost = parseFloat(argv[i++]);
+        break;
       case "--no-sync":
         args.sync = false;
         break;
@@ -177,7 +212,13 @@ async function cmdAdd(args: Args): Promise<void> {
   await indexer.upsertFile(args.teammate, args.file);
 
   if (args.json) {
-    console.log(JSON.stringify({ teammate: args.teammate, file: args.file, status: "ok" }));
+    console.log(
+      JSON.stringify({
+        teammate: args.teammate,
+        file: args.file,
+        status: "ok",
+      }),
+    );
   } else {
     console.log(`Added ${args.file} to ${args.teammate}'s index`);
   }
@@ -195,6 +236,10 @@ async function cmdSearch(args: Args): Promise<void> {
     teammatesDir,
     teammate: args.teammate,
     maxResults: args.results,
+    maxChunks: args.maxChunks,
+    maxTokens: args.maxTokens,
+    recencyDepth: args.recencyDepth,
+    typedMemoryBoost: args.typedMemoryBoost,
     model: args.model,
     skipSync: !args.sync,
   });
@@ -207,7 +252,9 @@ async function cmdSearch(args: Args): Promise<void> {
       return;
     }
     for (const result of results) {
-      console.log(`--- ${result.teammate} | ${result.uri} (score: ${result.score.toFixed(3)}) ---`);
+      console.log(
+        `--- ${result.teammate} | ${result.uri} (score: ${result.score.toFixed(3)}) ---`,
+      );
       console.log(result.text);
       console.log();
     }
@@ -244,6 +291,88 @@ async function cmdStatus(args: Args): Promise<void> {
   }
 }
 
+async function cmdWatch(args: Args): Promise<void> {
+  const teammatesDir = await resolveTeammatesDir(args.dir);
+  const indexer = new Indexer({ teammatesDir, model: args.model });
+
+  // Initial sync
+  console.error("Initial sync...");
+  const results = await indexer.syncAll();
+  for (const [teammate, count] of results) {
+    console.error(`  ${teammate}: ${count} files`);
+  }
+  console.error("Watching for changes...");
+
+  if (args.json) {
+    console.log(JSON.stringify({ status: "watching", dir: teammatesDir }));
+  }
+
+  // Debounce: collect changes, sync after 2s of quiet
+  let syncTimer: ReturnType<typeof setTimeout> | null = null;
+  const pendingTeammates = new Set<string>();
+
+  const scheduleSync = (teammate: string) => {
+    pendingTeammates.add(teammate);
+    if (syncTimer) clearTimeout(syncTimer);
+    syncTimer = setTimeout(async () => {
+      for (const t of pendingTeammates) {
+        try {
+          const count = await indexer.syncTeammate(t);
+          if (args.json) {
+            console.log(
+              JSON.stringify({ event: "sync", teammate: t, files: count }),
+            );
+          } else {
+            console.error(`  synced ${t}: ${count} files`);
+          }
+        } catch (err: unknown) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`  error syncing ${t}: ${msg}`);
+        }
+      }
+      pendingTeammates.clear();
+    }, 2000);
+  };
+
+  // Watch each teammate's directory for changes
+  const watchers: FSWatcher[] = [];
+  const teammates = await indexer.discoverTeammates();
+
+  for (const teammate of teammates) {
+    const teammateDir = path.join(teammatesDir, teammate);
+    try {
+      const watcher = fsWatch(
+        teammateDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+          // Only care about .md files, skip .index/
+          if (!filename.endsWith(".md") || filename.includes(".index")) return;
+          scheduleSync(teammate);
+        },
+      );
+      watchers.push(watcher);
+    } catch {
+      console.error(`  warning: could not watch ${teammate}/`);
+    }
+  }
+
+  // Keep alive until killed
+  const shutdown = () => {
+    if (syncTimer) clearTimeout(syncTimer);
+    for (const w of watchers) w.close();
+    if (args.json) {
+      console.log(JSON.stringify({ status: "stopped" }));
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
+  // Block forever
+  await new Promise(() => {});
+}
+
 async function main(): Promise<void> {
   const args = parseArgs(process.argv);
 
@@ -263,6 +392,9 @@ async function main(): Promise<void> {
     case "status":
       await cmdStatus(args);
       break;
+    case "watch":
+      await cmdWatch(args);
+      break;
     default:
       console.log(HELP);
       process.exit(args.command ? 1 : 0);

package/src/embeddings.ts

@@ -17,11 +17,13 @@ export class LocalEmbeddings implements EmbeddingsModel {
   }
 
   async createEmbeddings(
-    inputs: string | string[]
+    inputs: string | string[],
   ): Promise<EmbeddingsResponse> {
     try {
       const extractor = await this._getExtractor();
-      const texts = (Array.isArray(inputs) ? inputs : [inputs]).filter((t) => t.trim().length > 0);
+      const texts = (Array.isArray(inputs) ? inputs : [inputs]).filter(
+        (t) => t.trim().length > 0,
+      );
       if (texts.length === 0) {
         return { status: "success", output: [] };
       }

package/src/index.ts

@@ -1,3 +1,3 @@
 export { LocalEmbeddings } from "./embeddings.js";
 export { Indexer, type IndexerConfig } from "./indexer.js";
-export { search, type SearchOptions, type SearchResult } from "./search.js";
+export { type SearchOptions, type SearchResult, search } from "./search.js";