@desplega.ai/agent-swarm 1.80.0 → 1.80.1

package/src/tests/script-executor-registry.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+import { NativeScriptExecutor } from "../scripts-runtime/executors/native";
+import { getScriptExecutor } from "../scripts-runtime/executors/registry";
+
+describe("getScriptExecutor", () => {
+  test("defaults to native", () => {
+    expect(getScriptExecutor()).toBeInstanceOf(NativeScriptExecutor);
+  });
+
+  test("returns native when requested", () => {
+    expect(getScriptExecutor("native")).toBeInstanceOf(NativeScriptExecutor);
+  });
+
+  test("throws for unknown executors", () => {
+    expect(() => getScriptExecutor("e2b")).toThrow("Available: native");
+  });
+});

package/src/tests/scripts-db.test.ts

@@ -0,0 +1,329 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, initDb } from "../be/db";
+import {
+  deleteScript,
+  getScript,
+  getScriptVersion,
+  insertScript,
+  listScripts,
+  upsertScriptByName,
+} from "../be/scripts/db";
+import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
+
+const TEST_DB_PATH = "./test-scripts-db.sqlite";
+
+const noOpEmbeddingProvider = {
+  name: "test/noop-script-embedding",
+  dimensions: 1,
+  async embed() {
+    return null;
+  },
+  async embedBatch(texts: string[]) {
+    return texts.map(() => null);
+  },
+};
+
+const signatureJson = JSON.stringify({
+  args: { type: "object", properties: { value: { type: "number" } } },
+  result: { type: "object", properties: { doubled: { type: "number" } } },
+});
+
+async function clearDb() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+}
+
+function source(multiplier: number) {
+  return `export default function run(args: { value: number }) { return { doubled: args.value * ${multiplier} }; }`;
+}
+
+describe("scripts DB helpers", () => {
+  beforeAll(async () => {
+    await clearDb();
+    initDb(TEST_DB_PATH);
+    setScriptEmbeddingProviderForTests(noOpEmbeddingProvider);
+  });
+
+  afterAll(async () => {
+    setScriptEmbeddingProviderForTests(null);
+    closeDb();
+    await clearDb();
+  });
+
+  beforeEach(() => {
+    getDb().run("DELETE FROM scripts");
+  });
+
+  test("insertScript stores a live row and initial version", () => {
+    const script = insertScript({
+      name: "double",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "Double a value",
+      intent: "Reusable arithmetic transform",
+      signatureJson,
+      agentId: "agent-1",
+      typeChecked: true,
+    });
+
+    expect(script.name).toBe("double");
+    expect(script.scope).toBe("agent");
+    expect(script.scopeId).toBe("agent-1");
+    expect(script.version).toBe(1);
+    expect(script.isScratch).toBe(false);
+    expect(script.typeChecked).toBe(true);
+    expect(script.fsMode).toBe("none");
+
+    const version = getScriptVersion({ scriptId: script.id, version: 1 });
+    expect(version?.source).toBe(source(2));
+    expect(version?.changedByAgentId).toBe("agent-1");
+    expect(version?.changeReason).toBe("Initial creation");
+  });
+
+  test("upsertScriptByName deduplicates matching content without bumping version", async () => {
+    const first = await upsertScriptByName({
+      name: "same",
+      scope: "global",
+      source: source(2),
+      description: "First description",
+      intent: "First intent",
+      signatureJson,
+      agentId: "lead-1",
+    });
+
+    const second = await upsertScriptByName({
+      name: "same",
+      scope: "global",
+      source: source(2),
+      description: "Changed metadata should update without version bump",
+      intent: "Changed intent",
+      signatureJson,
+      agentId: "lead-1",
+    });
+
+    expect(first.isNew).toBe(true);
+    expect(second.isNew).toBe(false);
+    expect(second.contentDeduped).toBe(true);
+    expect(second.script.id).toBe(first.script.id);
+    expect(second.script.version).toBe(1);
+    expect(second.script.description).toBe("Changed metadata should update without version bump");
+    expect(
+      getDb()
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM script_versions WHERE scriptId = ?",
+        )
+        .get(first.script.id)?.count,
+    ).toBe(1);
+  });
+
+  test("upsertScriptByName bumps version and writes history on source change", async () => {
+    const first = await upsertScriptByName({
+      name: "mutating",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "v1",
+      intent: "Initial version",
+      signatureJson,
+      agentId: "agent-1",
+    });
+
+    const second = await upsertScriptByName({
+      name: "mutating",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(3),
+      description: "v2",
+      intent: "Updated multiplier",
+      signatureJson,
+      agentId: "agent-2",
+      changeReason: "Use triple",
+      typeChecked: true,
+    });
+
+    expect(second.isNew).toBe(false);
+    expect(second.contentDeduped).toBe(false);
+    expect(second.script.id).toBe(first.script.id);
+    expect(second.script.version).toBe(2);
+    expect(second.script.typeChecked).toBe(true);
+
+    const v1 = getScriptVersion({ scriptId: first.script.id, version: 1 });
+    const v2 = getScriptVersion({ scriptId: first.script.id, version: 2 });
+    expect(v1?.source).toBe(source(2));
+    expect(v2?.source).toBe(source(3));
+    expect(v2?.changeReason).toBe("Use triple");
+    expect(
+      getScriptVersion({ scriptId: first.script.id, contentHash: second.script.contentHash })
+        ?.version,
+    ).toBe(2);
+  });
+
+  test("scope uniqueness treats global null scopeId as one scope and isolates agent scopes", () => {
+    insertScript({
+      name: "shared-name",
+      scope: "global",
+      source: source(2),
+      description: "Global",
+      intent: "Global script",
+      signatureJson,
+    });
+
+    expect(() =>
+      insertScript({
+        name: "shared-name",
+        scope: "global",
+        source: source(3),
+        description: "Duplicate global",
+        intent: "Should fail",
+        signatureJson,
+      }),
+    ).toThrow();
+
+    const agentOne = insertScript({
+      name: "shared-name",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "Agent one",
+      intent: "Agent script",
+      signatureJson,
+    });
+    const agentTwo = insertScript({
+      name: "shared-name",
+      scope: "agent",
+      scopeId: "agent-2",
+      source: source(2),
+      description: "Agent two",
+      intent: "Agent script",
+      signatureJson,
+    });
+
+    expect(agentOne.id).not.toBe(agentTwo.id);
+    expect(() =>
+      insertScript({
+        name: "missing-scope",
+        scope: "agent",
+        source: source(2),
+        description: "No scopeId",
+        intent: "Should fail",
+        signatureJson,
+      }),
+    ).toThrow("scopeId is required");
+  });
+
+  test("listScripts filters scratch scripts by default", () => {
+    insertScript({
+      name: "explicit",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "Explicit",
+      intent: "Explicit script",
+      signatureJson,
+    });
+    insertScript({
+      name: "scratch",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(3),
+      description: "Scratch",
+      intent: "Scratch script",
+      signatureJson,
+      isScratch: true,
+    });
+
+    expect(
+      listScripts({ scope: "agent", scopeId: "agent-1" }).map((script) => script.name),
+    ).toEqual(["explicit"]);
+    expect(
+      listScripts({ scope: "agent", scopeId: "agent-1", includeScratch: true }).map(
+        (script) => script.name,
+      ),
+    ).toEqual(["explicit", "scratch"]);
+  });
+
+  test("deleteScript cascades script_versions", async () => {
+    const result = await upsertScriptByName({
+      name: "delete-me",
+      scope: "global",
+      source: source(2),
+      description: "Delete me",
+      intent: "Cascade check",
+      signatureJson,
+    });
+    await upsertScriptByName({
+      name: "delete-me",
+      scope: "global",
+      source: source(4),
+      description: "Delete me v2",
+      intent: "Cascade check",
+      signatureJson,
+    });
+
+    expect(deleteScript({ name: "delete-me", scope: "global" })).toBe(true);
+    expect(deleteScript({ name: "delete-me", scope: "global" })).toBe(false);
+    expect(getScript({ name: "delete-me", scope: "global" })).toBeNull();
+    expect(
+      getDb()
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM script_versions WHERE scriptId = ?",
+        )
+        .get(result.script.id)?.count,
+    ).toBe(0);
+  });
+
+  test("full lifecycle: upsert, dedup, version bump, history, delete", async () => {
+    const created = await upsertScriptByName({
+      name: "lifecycle",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "Lifecycle",
+      intent: "Exercise full lifecycle",
+      signatureJson,
+      agentId: "agent-1",
+    });
+    const deduped = await upsertScriptByName({
+      name: "lifecycle",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(2),
+      description: "Lifecycle changed",
+      intent: "No version bump",
+      signatureJson,
+      agentId: "agent-1",
+    });
+    const updated = await upsertScriptByName({
+      name: "lifecycle",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: source(5),
+      description: "Lifecycle updated",
+      intent: "Version bump",
+      signatureJson,
+      agentId: "agent-1",
+    });
+
+    expect(created.isNew).toBe(true);
+    expect(deduped.contentDeduped).toBe(true);
+    expect(deduped.script.version).toBe(1);
+    expect(updated.script.version).toBe(2);
+    expect(getScriptVersion({ scriptId: created.script.id, version: 1 })?.source).toBe(source(2));
+    expect(getScriptVersion({ scriptId: created.script.id, version: 2 })?.source).toBe(source(5));
+
+    expect(deleteScript({ name: "lifecycle", scope: "agent", scopeId: "agent-1" })).toBe(true);
+    expect(getScript({ name: "lifecycle", scope: "agent", scopeId: "agent-1" })).toBeNull();
+    expect(
+      getDb()
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM script_versions WHERE scriptId = ?",
+        )
+        .get(created.script.id)?.count,
+    ).toBe(0);
+  });
+});

package/src/tests/scripts-embeddings.test.ts

@@ -0,0 +1,291 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, initDb } from "../be/db";
+import type { EmbeddingProvider } from "../be/memory/types";
+import { getScript, upsertScriptByName } from "../be/scripts/db";
+import {
+  reembedAllScripts,
+  searchScripts,
+  setScriptEmbeddingProviderForTests,
+} from "../be/scripts/embeddings";
+import { runScriptsMaintenanceCommand } from "../be/scripts/maintenance";
+
+const TEST_DB_PATH = "./test-scripts-embeddings.sqlite";
+
+const signatureJson = JSON.stringify({
+  argsType: "{ value: string }",
+  resultType: "Promise<{ ok: boolean }>",
+  description: "",
+});
+
+async function clearDb() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+}
+
+function source(label: string) {
+  return `export default async () => ({ label: ${JSON.stringify(label)} });`;
+}
+
+function embeddingFor(text: string): Float32Array {
+  const lower = text.toLowerCase();
+  if (lower.includes("exact-name")) return new Float32Array([0.1, 0.995, 0, 0, 0]);
+
+  const vector = [0, 0, 0, 0, 0];
+  if (/(linear|issue|ticket|triage)/.test(lower)) vector[0] += 1;
+  if (/(github|pull request|\bpr\b|review|comments?)/.test(lower)) vector[1] += 1;
+  if (/(memory|recall|remember|search)/.test(lower)) vector[2] += 1;
+  if (/(slack|message|channel)/.test(lower)) vector[3] += 1;
+  if (/(csv|spreadsheet|table|rows?)/.test(lower)) vector[4] += 1;
+  return new Float32Array(vector);
+}
+
+class FakeEmbeddingProvider implements EmbeddingProvider {
+  readonly name = "test/fake-script-embedding";
+  readonly dimensions = 5;
+  readonly calls: string[] = [];
+
+  async embed(text: string): Promise<Float32Array | null> {
+    this.calls.push(text);
+    return embeddingFor(text);
+  }
+
+  async embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
+    return Promise.all(texts.map((text) => this.embed(text)));
+  }
+
+  reset(): void {
+    this.calls.length = 0;
+  }
+}
+
+let provider: FakeEmbeddingProvider;
+
+function embeddingCount(scriptId: string): number {
+  return (
+    getDb()
+      .prepare<{ count: number }, [string]>(
+        "SELECT COUNT(*) as count FROM script_embeddings WHERE scriptId = ?",
+      )
+      .get(scriptId)?.count ?? 0
+  );
+}
+
+function embeddedText(scriptId: string): string | null {
+  return (
+    getDb()
+      .prepare<{ embeddedText: string }, [string]>(
+        "SELECT embeddedText FROM script_embeddings WHERE scriptId = ?",
+      )
+      .get(scriptId)?.embeddedText ?? null
+  );
+}
+
+async function upsertFixture(args: {
+  name: string;
+  sourceLabel?: string;
+  description: string;
+  intent?: string;
+  isScratch?: boolean;
+}) {
+  return upsertScriptByName({
+    name: args.name,
+    scope: "agent",
+    scopeId: "agent-1",
+    source: source(args.sourceLabel ?? args.name),
+    description: args.description,
+    intent: args.intent ?? args.description,
+    signatureJson,
+    agentId: "agent-1",
+    isScratch: args.isScratch,
+    typeChecked: !args.isScratch,
+  });
+}
+
+beforeAll(async () => {
+  await clearDb();
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  setScriptEmbeddingProviderForTests(null);
+  closeDb();
+  await clearDb();
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM scripts");
+  provider = new FakeEmbeddingProvider();
+  setScriptEmbeddingProviderForTests(provider);
+});
+
+describe("script embeddings", () => {
+  test("migration applies and creates script_embeddings storage", () => {
+    const schema = getDb()
+      .prepare<{ sql: string }, []>(
+        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'script_embeddings'",
+      )
+      .get();
+    expect(schema?.sql).toContain("scriptId TEXT PRIMARY KEY");
+    expect(schema?.sql).toContain("embedding BLOB NOT NULL");
+  });
+
+  test("embeds explicit upserts and skips scratch upserts", async () => {
+    const explicit = await upsertFixture({
+      name: "linear-parser",
+      description: "Parse Linear issue payloads",
+    });
+    expect(embeddingCount(explicit.script.id)).toBe(1);
+
+    provider.reset();
+    const scratch = await upsertFixture({
+      name: "scratch-linear-parser",
+      description: "Scratch Linear issue payloads",
+      isScratch: true,
+    });
+    expect(embeddingCount(scratch.script.id)).toBe(0);
+    expect(provider.calls).toHaveLength(0);
+  });
+
+  test("re-embeds on body or searchable metadata changes, but not on no-op upsert", async () => {
+    const first = await upsertFixture({
+      name: "github-review",
+      sourceLabel: "v1",
+      description: "Group GitHub review comments",
+    });
+    expect(provider.calls).toHaveLength(1);
+
+    provider.reset();
+    await upsertFixture({
+      name: "github-review",
+      sourceLabel: "v2",
+      description: "Group GitHub review comments",
+    });
+    expect(provider.calls).toHaveLength(1);
+
+    provider.reset();
+    await upsertFixture({
+      name: "github-review",
+      sourceLabel: "v2",
+      description: "Summarize pull request review feedback",
+    });
+    expect(provider.calls).toHaveLength(1);
+    expect(embeddedText(first.script.id)).toContain("Summarize pull request review feedback");
+
+    provider.reset();
+    await upsertFixture({
+      name: "github-review",
+      sourceLabel: "v2",
+      description: "Summarize pull request review feedback",
+    });
+    expect(provider.calls).toHaveLength(0);
+  });
+
+  test("scripts reembed command backfills scripts promoted after scratch save", async () => {
+    const scratch = await upsertFixture({
+      name: "promoted-scratch",
+      description: "Parse Slack channel messages",
+      isScratch: true,
+    });
+    expect(embeddingCount(scratch.script.id)).toBe(0);
+
+    getDb().run("UPDATE scripts SET isScratch = 0 WHERE id = ?", [scratch.script.id]);
+    provider.reset();
+    await runScriptsMaintenanceCommand(["reembed"]);
+
+    expect(provider.calls).toHaveLength(1);
+    expect(embeddingCount(scratch.script.id)).toBe(1);
+  });
+
+  test("semantic search outranks name-substring-only matches", async () => {
+    await upsertFixture({
+      name: "review-grouper",
+      description: "Group GitHub pull request feedback by reviewer",
+    });
+    await upsertFixture({
+      name: "comments-sorter",
+      description: "Sort CSV table rows alphabetically",
+    });
+
+    provider.reset();
+    const results = await searchScripts({ query: "comments", scopeId: "agent-1", limit: 2 });
+    expect(results.map((result) => result.script.name)).toEqual([
+      "review-grouper",
+      "comments-sorter",
+    ]);
+  });
+
+  test("hybrid ranking lets an exact name match outrank a weaker semantic match", async () => {
+    await upsertFixture({
+      name: "exact-name",
+      description: "Unrelated helper",
+    });
+    await upsertFixture({
+      name: "semantic-weaker",
+      description: "Linear issue triage helper",
+    });
+
+    const results = await searchScripts({ query: "exact-name", scopeId: "agent-1", limit: 2 });
+    expect(results[0]?.script.name).toBe("exact-name");
+  });
+
+  test("semantic recall returns expected top results for overlapping intents", async () => {
+    const fixtures = [
+      ["linear-json-parser", "Parse Linear issue JSON into task fields"],
+      ["linear-ticket-router", "Route Linear tickets by team and priority"],
+      ["github-pr-comment-grouper", "Group GitHub pull request comments by file"],
+      ["github-review-summary", "Summarize PR review feedback and blockers"],
+      ["memory-fanout", "Fan out memory recall searches across related terms"],
+      ["memory-ranking", "Rank remembered notes by usefulness"],
+      ["slack-thread-digest", "Digest Slack channel messages into a summary"],
+      ["slack-alert-router", "Route Slack alerts to the right channel"],
+      ["csv-normalizer", "Normalize CSV spreadsheet rows for table output"],
+      ["table-formatter", "Format table rows into aligned text"],
+    ] as const;
+
+    for (const [name, description] of fixtures) {
+      await upsertFixture({ name, description });
+    }
+
+    const queries = [
+      ["issue payload fields", "linear-json-parser"],
+      ["pull request comments", "github-pr-comment-grouper"],
+      ["remembered search fanout", "memory-fanout"],
+      ["channel message digest", "slack-thread-digest"],
+      ["spreadsheet rows", "csv-normalizer"],
+    ] as const;
+
+    let topOneHits = 0;
+    for (const [query, expected] of queries) {
+      const results = await searchScripts({ query, scopeId: "agent-1", limit: 3 });
+      if (results[0]?.script.name === expected) topOneHits++;
+      expect(results.slice(0, 3).map((result) => result.script.name)).toContain(expected);
+    }
+
+    expect(topOneHits).toBeGreaterThanOrEqual(4);
+  });
+
+  test("reembedAllScripts updates every explicit script", async () => {
+    await upsertFixture({ name: "linear-one", description: "Linear issue parser" });
+    await upsertFixture({ name: "slack-one", description: "Slack message digest" });
+
+    provider.reset();
+    await reembedAllScripts();
+    expect(provider.calls).toHaveLength(2);
+  });
+
+  test("delete cascades script_embeddings", async () => {
+    const created = await upsertFixture({
+      name: "delete-embedding",
+      description: "Memory search helper",
+    });
+    expect(embeddingCount(created.script.id)).toBe(1);
+
+    getDb().run("DELETE FROM scripts WHERE id = ?", [created.script.id]);
+    expect(getScript({ name: "delete-embedding", scope: "agent", scopeId: "agent-1" })).toBeNull();
+    expect(embeddingCount(created.script.id)).toBe(0);
+  });
+});

package/src/tests/scripts-extract-signature.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { extractScriptSignature } from "../scripts-runtime/extract-signature";
+
+describe("extractScriptSignature", () => {
+  test("extracts arrow function destructured args and return type", () => {
+    const sig = extractScriptSignature(`
+      /** Adds one */
+      export default async ({ x }: { x: number }): Promise<{ y: number }> => ({ y: x + 1 });
+    `);
+    expect(sig.argsType).toBe("{ x: number }");
+    expect(sig.resultType).toBe("{ y: number }");
+    expect(sig.description).toBe("Adds one");
+  });
+
+  test("extracts generic async function declarations", () => {
+    const sig = extractScriptSignature(`
+      /** Generic mapper */
+      export default async function <T extends { id: string }>(
+        args: T
+      ): Promise<{
+        id: string;
+        ok: boolean;
+      }> {
+        return { id: args.id, ok: true };
+      }
+    `);
+    expect(sig.argsType).toBe("T");
+    expect(sig.resultType).toContain("ok: boolean");
+    expect(sig.description).toBe("Generic mapper");
+  });
+
+  test("falls back when no default export exists", () => {
+    expect(extractScriptSignature("export const x = 1")).toEqual({
+      argsType: "unknown",
+      resultType: "unknown",
+      description: "",
+    });
+  });
+
+  test("falls back on syntax error", () => {
+    expect(extractScriptSignature("export default async (")).toEqual({
+      argsType: "unknown",
+      resultType: "unknown",
+      description: "",
+    });
+  });
+});