Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

16.4 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import {
  repositoryLayer,
  makeRevision,
  privateAccess,
  insert,
  botAccess,
  sharedAccess,
} from "./testUtils/entityMemoryRepository.ts";
import { assert, it } from "@effect/vitest";
import {
  AkeruMemoryEntityId,
  AkeruMemoryId,
  AkeruMemoryPartitionId,
  AkeruMemoryRootId,
  AkeruMemoryTenantId,
  AkeruMemoryUserId,
  BotId,
} from "@akeru/contracts";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import {
  EntityMemoryConflictError,
  EntityMemoryRepository,
} from "../Services/EntityMemoryRepository.ts";
import { deriveAkeruWorkspaceId, resolveMemoryArchivePartitions } from "../EntityMemoryAccess.ts";

it.layer(repositoryLayer)("EntityMemoryRepository", (it) => {
  it.effect("queries only explicit authorized partitions", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      yield* insert(repository, makeRevision("first", "bot-1:user"));
      yield* insert(repository, makeRevision("second", "bot-2:user"));

      const rows = yield* repository.search({
        access: privateAccess("bot-1"),
        query: "prefers vim",
        limit: 10,
      });

      assert.deepEqual(
        rows.map((row) => row.id),
        ["first"],
      );
    }),
  );

  it.effect("rejects unapproved, forged, and mismatched direct inserts", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;

      const invalid = [
        makeRevision("pending-insert", "bot:user", { approvalState: "pending" }),
        makeRevision("forged-user-insert", "bot:user", {
          initiatingUserId: AkeruMemoryUserId.make("other-user"),
        }),
        makeRevision("forged-bot-insert", "bot:user", {
          authorBotId: BotId.make("other-bot"),
        }),
        makeRevision("mismatched-entity-insert", "bot:user", {
          entityKind: "project",
          entityId: AkeruMemoryEntityId.make("project"),
        }),
      ];

      const exits = yield* Effect.forEach(invalid, (revision) =>
        repository.insert({ access: botAccess, revision }).pipe(Effect.exit),
      );

      assert.isTrue(exits.every((exit) => Predicate.isTagged(exit, "Failure")));
    }),
  );

  it.effect("preserves revisions and rejects stale writes", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("root");
      const initial = makeRevision("memory-1", "bot:user", { rootId });
      yield* repository.insert({ access: botAccess, revision: initial });

      const next = makeRevision("memory-2", "bot:user", {
        rootId,
        revision: 2,
        supersedesId: initial.id,
        fact: "The user prefers helix.",
      });

      yield* repository.revise({ access: botAccess, revision: next, expectedRevision: 1 });
      const current = yield* repository.getCurrent({ access: botAccess, rootId });
      assert.equal(current.id, "memory-2");
      assert.equal(current.revision, 2);

      const stale = yield* repository
        .revise({
          access: botAccess,
          revision: makeRevision("memory-3", "bot:user", {
            rootId,
            revision: 2,
            supersedesId: initial.id,
          }),
          expectedRevision: 1,
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(stale, "Failure"));

      if (Predicate.isTagged(stale, "Failure")) {
        assert.instanceOf(Cause.squash(stale.cause), EntityMemoryConflictError);
      }
    }),
  );

  it.effect("does not let shared access delete an older private revision", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("delete-private-history-root");
      const initial = makeRevision("delete-private-history-1", "bot-1:user", { rootId });
      yield* repository.insert({ access: privateAccess("bot-1"), revision: initial });
      yield* repository.revise({
        access: privateAccess("bot-1"),
        expectedRevision: 1,
        revision: makeRevision("delete-private-history-2", "project", {
          rootId,
          revision: 2,
          supersedesId: initial.id,
          partition: {
            tenantId: AkeruMemoryTenantId.make("tenant"),
            scope: "project",
            partitionId: AkeruMemoryPartitionId.make("project"),
          },
          entityKind: "project",
          entityId: AkeruMemoryEntityId.make("project"),
          visibility: "shared",
          authorBotId: BotId.make("bot-1"),
          affectedBotIds: [BotId.make("bot-1")],
        }),
      });

      const exit = yield* repository
        .deleteRoot({
          access: privateAccess("bot-2"),
          rootId,
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(exit, "Failure"));
    }),
  );

  it.effect("removes a tombstone from recall before cleanup", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("forget-root");
      yield* repository.insert({
        access: botAccess,
        revision: makeRevision("active", "bot:user", {
          rootId,
          fact: "secret-disappear-value",
        }),
      });
      const sql = yield* SqlClient.SqlClient;
      yield* sql`INSERT INTO akeru_memory_derived_copies (tenant_id, root_id, revision_id, thread_id, created_at)
        VALUES (${botAccess.tenantId}, ${rootId}, ${AkeruMemoryId.make("active")}, ${botAccess.threadId}, ${"2026-08-30T22:00:00.000Z"})`;
      yield* repository.tombstone({
        access: botAccess,
        rootId,
        expectedRevision: 1,
        memoryId: AkeruMemoryId.make("tombstone"),
        updatedAt: "2026-08-30T22:00:00.000Z",
      });

      const rows = yield* repository.search({
        access: botAccess,
        query: "secret-disappear-value",
        limit: 10,
      });

      assert.equal(rows.length, 0);

      const ftsRows = yield* sql<{
        readonly memory_id: string;
      }>`SELECT memory_id FROM akeru_memory_fts WHERE memory_id = ${"active"}`;

      assert.deepEqual(ftsRows, []);

      const derivedRows = yield* sql<{
        readonly root_id: string;
      }>`SELECT root_id FROM akeru_memory_derived_copies WHERE root_id = ${rootId}`;

      assert.deepEqual(derivedRows, []);
      const current = yield* repository.getCurrent({ access: botAccess, rootId });
      assert.equal(current.deletionState, "tombstoned");
      assert.equal(current.revision, 2);
      assert.isFalse(
        (yield* repository.listCurrent({ access: botAccess })).some(
          (revision) => revision.rootId === rootId,
        ),
      );

      const resurrection = yield* repository
        .revise({
          access: botAccess,
          expectedRevision: 2,
          revision: makeRevision("resurrected", "bot:user", {
            rootId,
            revision: 3,
            supersedesId: current.id,
            fact: "This must stay forgotten.",
          }),
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(resurrection, "Failure"));

      if (Predicate.isTagged(resurrection, "Failure")) {
        assert.instanceOf(Cause.squash(resurrection.cause), EntityMemoryConflictError);
      }
    }),
  );

  it.effect("does not read another bot's memory by root id", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("private-root");
      yield* repository.insert({
        access: privateAccess("bot-1"),
        revision: makeRevision("private-memory", "bot-1:user", { rootId }),
      });

      const exit = yield* repository
        .getCurrent({
          access: privateAccess("bot-2"),
          rootId,
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(exit, "Failure"));
    }),
  );

  it.effect("rejects private partitions for shared threads", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;

      const exit = yield* repository
        .insert({
          access: sharedAccess,
          revision: makeRevision("shared-private", "bot:user"),
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(exit, "Failure"));
    }),
  );

  it.effect("classifies identical, extending, divergent, and re-homed histories", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const sql = yield* SqlClient.SqlClient;
      const partitions = yield* resolveMemoryArchivePartitions(botAccess, "bot");
      const rootId = AkeruMemoryRootId.make("classified-import-root");

      const first = makeRevision("classified-import-1", "bot", {
        rootId,
        partition: {
          tenantId: botAccess.tenantId,
          scope: "bot",
          partitionId: AkeruMemoryPartitionId.make(botAccess.botId!),
        },
        entityKind: "bot",
        entityId: AkeruMemoryEntityId.make(botAccess.botId!),
        sourceThreadId: null,
        sourceMessageId: null,
        authorBotId: botAccess.botId,
        initiatingUserId: botAccess.userId,
        affectedBotIds: [botAccess.botId!],
      });

      yield* repository.insert({ access: botAccess, revision: first });

      const skipped = yield* repository.previewImport!({
        access: botAccess,
        partitions,
        revisions: [first],
      });

      assert.equal(skipped.items[0]?.classification, "skipped");

      const second = makeRevision("classified-import-2", "bot", {
        ...first,
        id: AkeruMemoryId.make("classified-import-2"),
        revision: 2,
        supersedesId: first.id,
        supersededById: null,
        fact: "The bot now uses Helix.",
        updatedAt: "2026-08-30T22:00:00.000Z",
      });

      const extendingFirst = { ...first, supersededById: second.id };

      const changed = yield* repository.previewImport!({
        access: botAccess,
        partitions,
        revisions: [extendingFirst, second],
      });

      assert.equal(changed.items[0]?.classification, "changed");
      yield* sql`INSERT INTO akeru_memory_derived_copies (tenant_id, root_id, revision_id, thread_id, created_at)
        VALUES (${botAccess.tenantId}, ${rootId}, ${first.id}, ${botAccess.threadId}, ${first.updatedAt})`;
      yield* repository.applyImport!({
        access: botAccess,
        partitions,
        revisions: [extendingFirst, second],
        previewHash: changed.previewHash,
      });
      assert.deepEqual(
        yield* sql`SELECT root_id FROM akeru_memory_derived_copies WHERE root_id = ${rootId}`,
        [],
      );

      const divergent = yield* repository.previewImport!({
        access: botAccess,
        partitions,
        revisions: [{ ...first, fact: "A divergent history." }],
      });

      assert.equal(divergent.items[0]?.classification, "conflicting");

      const unresolved = yield* repository
        .applyImport({
          access: botAccess,
          partitions,
          revisions: [{ ...first, fact: "A divergent history." }],
          previewHash: divergent.previewHash,
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(unresolved, "Failure"));
      yield* repository.applyImport!({
        access: botAccess,
        partitions,
        revisions: [{ ...first, fact: "A divergent history." }],
        previewHash: divergent.previewHash,
        resolutions: [{ rootId: first.rootId, decision: "use-archive" }],
      });
      const replaced = yield* repository.getCurrent({ access: botAccess, rootId: first.rootId });
      assert.equal(replaced.fact, "A divergent history.");

      const sharedRootId = AkeruMemoryRootId.make("rehome-import-root");
      yield* repository.insert({
        access: botAccess,
        revision: makeRevision("rehome-local", "project", {
          rootId: sharedRootId,
          partition: {
            tenantId: botAccess.tenantId,
            scope: "project",
            partitionId: AkeruMemoryPartitionId.make(botAccess.projectId),
          },
          entityKind: "project",
          entityId: AkeruMemoryEntityId.make(botAccess.projectId),
          visibility: "shared",
        }),
      });

      const rehome = yield* repository.previewImport!({
        access: botAccess,
        partitions,
        revisions: [makeRevision("rehome-archive", "bot", { rootId: sharedRootId })],
      }).pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(rehome, "Failure"));
    }),
  );

  it.effect("edits and pins memory in the legacy workspace partition", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const workspaceAccess = privateAccess("bot-legacy-workspace");
      const workspaceId = deriveAkeruWorkspaceId(workspaceAccess.projectId);

      const legacyWorkspaceId = (yield* resolveMemoryArchivePartitions(
        workspaceAccess,
        "workspace",
      )).find((partition) => partition.partitionId !== workspaceId)?.partitionId;

      if (!legacyWorkspaceId) return assert.fail("Expected a legacy workspace partition.");
      const rootId = AkeruMemoryRootId.make("legacy-workspace-root");

      const initial = makeRevision("legacy-workspace-1", legacyWorkspaceId, {
        rootId,
        partition: {
          tenantId: workspaceAccess.tenantId,
          scope: "workspace",
          partitionId: legacyWorkspaceId,
        },
        entityKind: "workspace",
        entityId: AkeruMemoryEntityId.make(legacyWorkspaceId),
        visibility: "shared",
        sourceThreadId: null,
        authorBotId: workspaceAccess.botId,
        initiatingUserId: workspaceAccess.userId,
        affectedBotIds: [workspaceAccess.botId!],
      });

      const edited = {
        ...initial,
        id: AkeruMemoryId.make("legacy-workspace-2"),
        revision: 2,
        supersedesId: initial.id,
        fact: "The legacy workspace fact was edited.",
      };

      const pinned = {
        ...edited,
        id: AkeruMemoryId.make("legacy-workspace-3"),
        revision: 3,
        supersedesId: edited.id,
        pinned: true,
      };

      yield* repository.insert({ access: workspaceAccess, revision: initial });
      yield* repository.revise({ access: workspaceAccess, revision: edited, expectedRevision: 1 });
      yield* repository.revise({ access: workspaceAccess, revision: pinned, expectedRevision: 2 });

      const current = yield* repository.getCurrent({ access: workspaceAccess, rootId });
      assert.equal(current.fact, edited.fact);
      assert.isTrue(current.pinned);
    }),
  );

  it.effect("changes scope only to an owner-valid target", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("mutate-scope-root");
      yield* repository.insert({
        access: botAccess,
        revision: makeRevision("mutate-scope-1", "bot:user", { rootId }),
      });

      const moved = yield* repository.applyMutation({
        access: botAccess,
        mutation: {
          operation: "fact.scope",
          memoryId: rootId,
          expectedRevision: 1,
          scope: "project",
        },
        memoryId: AkeruMemoryId.make("mutate-scope-2"),
        updatedAt: "2026-08-30T22:30:00.000Z",
        sharedProjectApproval: "approved",
      });

      assert.equal(moved!.partition.scope, "project");
      assert.equal(moved!.entityKind, "project");
      assert.equal(moved!.visibility, "shared");

      const back = yield* repository.applyMutation({
        access: botAccess,
        mutation: {
          operation: "fact.scope",
          memoryId: rootId,
          expectedRevision: 2,
          scope: "bot",
        },
        memoryId: AkeruMemoryId.make("mutate-scope-3"),
        updatedAt: "2026-08-30T22:31:00.000Z",
        sharedProjectApproval: "approved",
      });

      assert.equal(back!.partition.scope, "bot");
      assert.equal(back!.visibility, "private");

      // A group scope is not owned by a one-to-one thread and must fail.
      const denied = yield* repository
        .applyMutation({
          access: botAccess,
          mutation: {
            operation: "fact.scope",
            memoryId: rootId,
            expectedRevision: 3,
            scope: "group",
          },
          memoryId: AkeruMemoryId.make("mutate-scope-4"),
          updatedAt: "2026-08-30T22:32:00.000Z",
          sharedProjectApproval: "approved",
        })
        .pipe(Effect.exit);

      assert.isTrue(Predicate.isTagged(denied, "Failure"));
    }),
  );
});