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.

8.2 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import {
  repositoryLayer,
  makeRevision,
  insert,
  botAccess,
} from "./testUtils/entityMemoryRepository.ts";
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import { assert, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import {
  AkeruMemoryEntityId,
  AkeruMemoryId,
  AkeruMemoryPartitionId,
  AkeruMemoryRootId,
  AkeruMemoryUserId,
  BotId,
} from "@akeru/contracts";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import { sqlitePersistenceLayer } from "../../persistence/Layers/Sqlite.ts";
import {
  EntityMemoryConflictError,
  EntityMemoryRepository,
} from "../Services/EntityMemoryRepository.ts";
import { MemoryRevisionWriteLockLive } from "../Services/MemoryRevisionWriteLock.ts";
import { EntityMemoryRepositoryLive } from "./EntityMemoryRepository.ts";
import { resolveMemoryArchivePartitions } from "../EntityMemoryAccess.ts";

it("preserves revision history and FTS recall after repository restart", () =>
  Effect.gen(function* () {
    const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-memory-restart-"));
    const dbPath = NodePath.join(directory, "state.sqlite");

    const restartedLayer = EntityMemoryRepositoryLive.pipe(
      Layer.provide(MemoryRevisionWriteLockLive),
      Layer.provideMerge(sqlitePersistenceLayer(dbPath).pipe(Layer.provide(NodeServices.layer))),
    );

    const rootId = AkeruMemoryRootId.make("restart-memory-root");

    const first = makeRevision("restart-memory-1", "bot:user", {
      rootId,
      fact: "restart marker old value",
    });

    const second = makeRevision("restart-memory-2", "bot:user", {
      rootId,
      revision: 2,
      supersedesId: first.id,
      fact: "restart marker current value",
    });

    yield* Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      yield* repository.insert({ access: botAccess, revision: first });
      yield* repository.revise({ access: botAccess, revision: second, expectedRevision: 1 });
    }).pipe(Effect.provide(restartedLayer));
    yield* Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const history = yield* repository.listHistory({ access: botAccess, rootId });
      assert.deepEqual(
        history.map((revision) => revision.id),
        [second.id, first.id],
      );

      const recalled = yield* repository.search({
        access: botAccess,
        query: "restart marker current",
        limit: 10,
      });

      assert.deepEqual(
        recalled.map((revision) => revision.id),
        [second.id],
      );
    }).pipe(Effect.provide(restartedLayer));
    NodeFS.rmSync(directory, { recursive: true, force: true });
  }));

it.layer(repositoryLayer)("EntityMemoryRepository", (it) => {
  it.effect("rejects unapproved, forged, and mismatched direct revisions", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("validated-revise-root");
      const first = makeRevision("validated-revise-1", "bot:user", { rootId });
      yield* repository.insert({ access: botAccess, revision: first });

      const baseRevision = makeRevision("validated-revise-2", "bot:user", {
        rootId,
        revision: 2,
        supersedesId: first.id,
      });

      const invalid = [
        { ...baseRevision, approvalState: "rejected" as const },
        { ...baseRevision, initiatingUserId: AkeruMemoryUserId.make("other-user") },
        { ...baseRevision, authorBotId: BotId.make("other-bot") },
        {
          ...baseRevision,
          entityKind: "project" as const,
          entityId: AkeruMemoryEntityId.make("project"),
        },
      ];

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

      assert.isTrue(exits.every((exit) => Predicate.isTagged(exit, "Failure")));
      assert.equal((yield* repository.getCurrent({ access: botAccess, rootId })).id, first.id);
    }),
  );

  it.effect("does not return all memory for punctuation-only search", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      yield* insert(repository, makeRevision("punctuation-memory", "bot:user"));
      assert.deepEqual(
        yield* repository.search({
          access: botAccess,
          query: "🤖?!",
          limit: 10,
        }),
        [],
      );
    }),
  );

  it.effect("rejects a second current head for the same tenant and root", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("single-head-root");
      yield* repository.insert({
        access: botAccess,
        revision: makeRevision("head-1", "bot:user", { rootId }),
      });

      const exit = yield* repository
        .insert({
          access: botAccess,
          revision: makeRevision("head-2", "bot:user", { rootId }),
        })
        .pipe(Effect.exit);

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

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

  it.effect("does not let a revision move to another partition", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const rootId = AkeruMemoryRootId.make("fixed-partition-root");
      const initial = makeRevision("fixed-1", "bot:user", { rootId });
      yield* repository.insert({ access: botAccess, revision: initial });

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

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

  it.effect("rejects gaps and broken links after a redacted project history prefix", () =>
    Effect.gen(function* () {
      const repository = yield* EntityMemoryRepository;
      const partitions = yield* resolveMemoryArchivePartitions(botAccess, "project");
      const rootId = AkeruMemoryRootId.make("redacted-invalid-chain-root");

      const first = makeRevision("redacted-invalid-chain-3", "project", {
        rootId,
        revision: 3,
        partition: {
          tenantId: botAccess.tenantId,
          scope: "project",
          partitionId: AkeruMemoryPartitionId.make(botAccess.projectId),
        },
        entityKind: "project",
        entityId: AkeruMemoryEntityId.make(botAccess.projectId),
        visibility: "shared",
        supersedesId: AkeruMemoryId.make("redacted-private-2"),
        supersededById: AkeruMemoryId.make("redacted-invalid-chain-4"),
      });

      const second = {
        ...first,
        id: AkeruMemoryId.make("redacted-invalid-chain-4"),
        revision: 4,
        supersedesId: first.id,
        supersededById: null,
      };

      const invalidHistories = [
        [first, { ...second, revision: 5 }],
        [first, { ...second, supersedesId: AkeruMemoryId.make("missing-project-revision") }],
        [first],
      ];

      for (const revisions of invalidHistories) {
        const preview = yield* repository.previewImport({
          access: botAccess,
          partitions,
          revisions,
        });

        assert.equal(preview.items[0]?.classification, "conflicting");
        assert.equal(preview.items[0]?.reason, "The archive revision chain is invalid.");

        const exit = yield* repository
          .applyImport({
            access: botAccess,
            partitions,
            revisions,
            previewHash: preview.previewHash,
            resolutions: [{ rootId, decision: "use-archive" }],
          })
          .pipe(Effect.exit);

        assert.equal(exit._tag, "Failure");
      }

      const missing = yield* repository.getCurrent({ access: botAccess, rootId }).pipe(Effect.flip);
      assert.equal(missing._tag, "EntityMemoryNotFoundError");
    }),
  );
});