@desplega.ai/agent-swarm 1.103.0 → 1.104.0

package/src/tests/memory-edit.test.ts

@@ -0,0 +1,177 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import { applyEditMode, SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+
+const TEST_DB_PATH = "./test-memory-edit.sqlite";
+const agentId = "aaaa0000-0000-4000-8000-000000000201";
+
+describe("applyEditMode", () => {
+  test("replace mode returns new content", () => {
+    const result = applyEditMode("replace", "old body", { content: "new body" });
+    expect(result).toBe("new body");
+  });
+
+  test("replace mode throws without content", () => {
+    expect(() => applyEditMode("replace", "old body", {})).toThrow("replace mode requires content");
+  });
+
+  test("exact mode performs surgical replacement", () => {
+    const result = applyEditMode("exact", "hello world foo", {
+      oldString: "world",
+      newString: "earth",
+    });
+    expect(result).toBe("hello earth foo");
+  });
+
+  test("exact mode with empty newString deletes the substring", () => {
+    const result = applyEditMode("exact", "hello world", {
+      oldString: " world",
+      newString: "",
+    });
+    expect(result).toBe("hello");
+  });
+
+  test("exact mode throws when oldString is not found", () => {
+    expect(() =>
+      applyEditMode("exact", "hello world", { oldString: "missing", newString: "x" }),
+    ).toThrow("oldString not found");
+  });
+
+  test("exact mode throws when oldString is ambiguous", () => {
+    expect(() =>
+      applyEditMode("exact", "alpha beta alpha", { oldString: "alpha", newString: "x" }),
+    ).toThrow("oldString is ambiguous");
+  });
+
+  test("exact mode throws without required fields", () => {
+    expect(() => applyEditMode("exact", "content", { newString: "x" })).toThrow(
+      "exact mode requires oldString and newString",
+    );
+    expect(() => applyEditMode("exact", "content", { oldString: "c" })).toThrow(
+      "exact mode requires oldString and newString",
+    );
+  });
+});
+
+describe("memory editing", () => {
+  let store: SqliteMemoryStore;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    createAgent({ id: agentId, name: "Edit Test Agent", isLead: false, status: "idle" });
+    store = new SqliteMemoryStore();
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+  });
+
+  test("preserves id and posterior while writing a version row", () => {
+    const memory = store.store({
+      agentId,
+      scope: "agent",
+      name: "editable",
+      content: "old body",
+      source: "manual",
+      key: "notes/editable.md",
+      intent: "seed test memory",
+    });
+    getDb().prepare("UPDATE agent_memory SET alpha = 3, beta = 2 WHERE id = ?").run(memory.id);
+
+    const result = store.edit({
+      id: memory.id,
+      mode: "replace",
+      content: "new body",
+      intent: "correct stale body",
+      changedByAgentId: agentId,
+    });
+
+    expect(result.changed).toBe(true);
+    expect(result.memory.id).toBe(memory.id);
+    expect(result.version).toBe(2);
+    const row = getDb()
+      .prepare<{ alpha: number; beta: number; content: string; version: number }, [string]>(
+        "SELECT alpha, beta, content, version FROM agent_memory WHERE id = ?",
+      )
+      .get(memory.id);
+    expect(row).toEqual({ alpha: 3, beta: 2, content: "new body", version: 2 });
+
+    const versions = getDb()
+      .prepare<{ version: number; operation: string; intent: string }, [string]>(
+        "SELECT version, operation, intent FROM agent_memory_version WHERE memory_id = ? ORDER BY version",
+      )
+      .all(memory.id);
+    expect(versions.map((version) => [version.version, version.operation])).toEqual([
+      [1, "create"],
+      [2, "edit"],
+    ]);
+    expect(versions[1]?.intent).toBe("correct stale body");
+  });
+
+  test("short-circuits unchanged content", () => {
+    const memory = store.store({
+      agentId,
+      scope: "agent",
+      name: "same",
+      content: "same body",
+      source: "manual",
+    });
+
+    const result = store.edit({
+      id: memory.id,
+      mode: "replace",
+      content: "same body",
+      intent: "noop",
+    });
+
+    expect(result.changed).toBe(false);
+    expect(result.version).toBe(1);
+    const versionCount = getDb()
+      .prepare<{ count: number }, [string]>(
+        "SELECT COUNT(*) AS count FROM agent_memory_version WHERE memory_id = ?",
+      )
+      .get(memory.id)?.count;
+    expect(versionCount).toBe(1);
+  });
+
+  test("exact mode rejects missing and ambiguous old strings", () => {
+    const memory = store.store({
+      agentId,
+      scope: "agent",
+      name: "exact",
+      content: "alpha beta alpha",
+      source: "manual",
+    });
+
+    expect(() =>
+      store.edit({
+        id: memory.id,
+        mode: "exact",
+        oldString: "missing",
+        newString: "x",
+        intent: "test missing",
+      }),
+    ).toThrow("oldString not found");
+
+    expect(() =>
+      store.edit({
+        id: memory.id,
+        mode: "exact",
+        oldString: "alpha",
+        newString: "x",
+        intent: "test ambiguous",
+      }),
+    ).toThrow("oldString is ambiguous");
+  });
+});

package/src/tests/memory-hybrid.test.ts

@@ -0,0 +1,212 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import { computeRrfScore, SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+
+const TEST_DB_PATH = "./test-memory-hybrid.sqlite";
+const agentId = "aaaa0000-0000-4000-8000-000000000101";
+
+function vector(value: number): Float32Array {
+  const embedding = new Float32Array(512);
+  embedding[0] = value;
+  return embedding;
+}
+
+describe("computeRrfScore", () => {
+  test("rank 0 with no decay produces max reciprocal score", () => {
+    const score = computeRrfScore(0, 1.0);
+    expect(score).toBeCloseTo(1 / 61, 6);
+  });
+
+  test("higher rank produces lower score", () => {
+    expect(computeRrfScore(0, 1.0)).toBeGreaterThan(computeRrfScore(5, 1.0));
+    expect(computeRrfScore(5, 1.0)).toBeGreaterThan(computeRrfScore(50, 1.0));
+  });
+
+  test("decay factor scales the score linearly", () => {
+    const full = computeRrfScore(3, 1.0);
+    const half = computeRrfScore(3, 0.5);
+    expect(half).toBeCloseTo(full * 0.5, 6);
+  });
+
+  test("custom k changes the smoothing constant", () => {
+    const defaultK = computeRrfScore(0, 1.0, 60);
+    const smallK = computeRrfScore(0, 1.0, 10);
+    expect(smallK).toBeGreaterThan(defaultK);
+    expect(smallK).toBeCloseTo(1 / 11, 6);
+  });
+
+  test("two arms sum to compound a memory that appears in both", () => {
+    const vecScore = computeRrfScore(0, 1.0);
+    const ftsScore = computeRrfScore(2, 1.0);
+    const compound = vecScore + ftsScore;
+    expect(compound).toBeGreaterThan(vecScore);
+    expect(compound).toBeGreaterThan(ftsScore);
+  });
+});
+
+describe("memory hybrid search", () => {
+  let store: SqliteMemoryStore;
+  let prevHybridFlag: string | undefined;
+
+  beforeAll(async () => {
+    prevHybridFlag = process.env.MEMORY_HYBRID_SEARCH;
+    process.env.MEMORY_HYBRID_SEARCH = "1";
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    createAgent({ id: agentId, name: "Hybrid Test Agent", isLead: false, status: "idle" });
+    store = new SqliteMemoryStore();
+  });
+
+  afterAll(async () => {
+    if (prevHybridFlag === undefined) delete process.env.MEMORY_HYBRID_SEARCH;
+    else process.env.MEMORY_HYBRID_SEARCH = prevHybridFlag;
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+  });
+
+  test("syncs FTS rows on store and delete", () => {
+    const memory = store.store({
+      agentId,
+      scope: "agent",
+      name: "lexical row",
+      content: "contains frobnicate-token",
+      source: "manual",
+    });
+
+    const inserted = getDb()
+      .prepare<{ count: number }, [string]>(
+        "SELECT COUNT(*) AS count FROM memory_fts WHERE memory_id = ?",
+      )
+      .get(memory.id)?.count;
+    expect(inserted).toBe(1);
+
+    store.delete(memory.id);
+    const deleted = getDb()
+      .prepare<{ count: number }, [string]>(
+        "SELECT COUNT(*) AS count FROM memory_fts WHERE memory_id = ?",
+      )
+      .get(memory.id)?.count;
+    expect(deleted).toBe(0);
+  });
+
+  test("uses keyword arm for exact terms and dedupes fused results", () => {
+    const exact = store.store({
+      agentId,
+      scope: "agent",
+      name: "runbook",
+      content: "The incident codeword is quasarneedle.",
+      source: "manual",
+    });
+    const semantic = store.store({
+      agentId,
+      scope: "agent",
+      name: "general note",
+      content: "A generic operational note.",
+      source: "manual",
+    });
+    store.updateEmbedding(exact.id, vector(1), "test");
+    store.updateEmbedding(semantic.id, vector(1), "test");
+
+    const results = store.search(vector(1), agentId, {
+      scope: "agent",
+      limit: 10,
+      queryText: "quasarneedle",
+    });
+
+    expect(results.some((result) => result.id === exact.id)).toBe(true);
+    expect(new Set(results.map((result) => result.id)).size).toBe(results.length);
+    expect(results.find((result) => result.id === exact.id)?.retrievalSource).toBe("hybrid");
+    expect(results.find((result) => result.id === semantic.id)?.retrievalSource).toBe("vec");
+  });
+
+  test("hybrid RRF compounds memories present in both vector and FTS arms", () => {
+    const both = store.store({
+      agentId,
+      scope: "agent",
+      name: "compound exact",
+      content: "The exact compound marker is rrfneedle.",
+      source: "manual",
+    });
+    const vectorOnly = store.store({
+      agentId,
+      scope: "agent",
+      name: "compound semantic",
+      content: "A semantic-only note.",
+      source: "manual",
+    });
+    store.updateEmbedding(both.id, vector(1), "test");
+    store.updateEmbedding(vectorOnly.id, vector(1), "test");
+
+    const results = store.search(vector(1), agentId, {
+      scope: "agent",
+      limit: 10,
+      queryText: "rrfneedle",
+    });
+
+    const bothResult = results.find((result) => result.id === both.id);
+    const vectorOnlyResult = results.find((result) => result.id === vectorOnly.id);
+    expect(bothResult?.retrievalSource).toBe("hybrid");
+    expect(vectorOnlyResult?.retrievalSource).toBe("vec");
+    expect(bothResult!.similarity).toBeGreaterThan(vectorOnlyResult!.similarity);
+  });
+
+  test("falls back to keyword-only search when vector query is unavailable", () => {
+    const exact = store.store({
+      agentId,
+      scope: "agent",
+      name: "keyword fallback",
+      content: "The fallback marker is lexiconneedle.",
+      source: "manual",
+    });
+
+    const results = store.search(new Float32Array(0), agentId, {
+      scope: "agent",
+      limit: 5,
+      queryText: "lexiconneedle",
+    });
+
+    expect(results.map((result) => result.id)).toContain(exact.id);
+    expect(results.find((result) => result.id === exact.id)?.retrievalSource).toBe("fts");
+  });
+
+  test("applies source-aware recency decay to FTS-only ranking", () => {
+    const stale = store.store({
+      agentId,
+      scope: "agent",
+      name: "stale keyword",
+      content: "The decay marker is decayneedle.",
+      source: "task_completion",
+    });
+    const fresh = store.store({
+      agentId,
+      scope: "agent",
+      name: "fresh keyword",
+      content: "The decay marker is decayneedle.",
+      source: "task_completion",
+    });
+    getDb()
+      .prepare("UPDATE agent_memory SET createdAt = ? WHERE id = ?")
+      .run(new Date(Date.now() - 60 * 86400000).toISOString(), stale.id);
+
+    const results = store.search(new Float32Array(0), agentId, {
+      scope: "agent",
+      limit: 10,
+      queryText: "decayneedle",
+    });
+
+    const staleIndex = results.findIndex((result) => result.id === stale.id);
+    const freshIndex = results.findIndex((result) => result.id === fresh.id);
+    expect(freshIndex).toBeGreaterThanOrEqual(0);
+    expect(staleIndex).toBeGreaterThanOrEqual(0);
+    expect(freshIndex).toBeLessThan(staleIndex);
+  });
+});

package/src/tests/runner-repo-autostash.test.ts

@@ -10,13 +10,40 @@ const execFileAsync = promisify(execFile);
 
 let tempRoot = "";
 
+function gitEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (key === "GIT_CONFIG_NOSYSTEM" || key.startsWith("GIT_TRACE")) continue;
+    if (key.startsWith("GIT_")) delete env[key];
+  }
+  return env;
+}
+
 async function git(cwd: string, args: string[]): Promise<string> {
-  const { stdout } = await execFileAsync("git", ["-C", cwd, ...args]);
+  const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], { env: gitEnv() });
   return stdout;
 }
 
 async function gitRaw(args: string[]): Promise<void> {
-  await execFileAsync("git", args);
+  await execFileAsync("git", args, { env: gitEnv() });
+}
+
+async function withCleanGitEnv<T>(fn: () => Promise<T>): Promise<T> {
+  const removed = new Map<string, string>();
+  for (const key of Object.keys(process.env)) {
+    if (key === "GIT_CONFIG_NOSYSTEM" || key.startsWith("GIT_TRACE")) continue;
+    if (!key.startsWith("GIT_")) continue;
+    const value = process.env[key];
+    if (value !== undefined) removed.set(key, value);
+    delete process.env[key];
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const [key, value] of removed) {
+      process.env[key] = value;
+    }
+  }
 }
 
 async function commitAll(cwd: string, message: string): Promise<void> {
@@ -63,9 +90,11 @@ describe("ensureRepoForTask auto-stash refresh", () => {
     await commitAll(upstreamPath, "remote update");
     await git(upstreamPath, ["push", "origin", "main"]);
 
-    const result = await ensureRepoForTask(
-      { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
-      "test",
+    const result = await withCleanGitEnv(() =>
+      ensureRepoForTask(
+        { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+        "test",
+      ),
     );
 
     expect(result.warning).toBeNull();
@@ -103,9 +132,11 @@ describe("ensureRepoForTask auto-stash refresh", () => {
     await commitAll(upstreamPath, "remote commit");
     await git(upstreamPath, ["push", "origin", "main"]);
 
-    const result = await ensureRepoForTask(
-      { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
-      "test",
+    const result = await withCleanGitEnv(() =>
+      ensureRepoForTask(
+        { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+        "test",
+      ),
     );
 
     expect(result.warning).toBeNull();