MemorySearchConfig,

OpenClawConfig,

} from "openclaw/plugin-sdk/memory-core-host-engine-foundation";

import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

import type { MemoryIndexManager } from "./index.js";

import { registerBuiltInMemoryEmbeddingProviders } from "./provider-adapters.js";

import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from "vitest";

type WatchIgnoredFn = (watchPath: string, stats?: { isDirectory?: () => boolean }) => boolean;

return watcher;

}

const watchers: Array<ReturnType<typeof createMockWatcher>> = [];

return {

const result = {

createdWatchers: watchers,

watchMock: vi.fn(() => {

const watcher = createMockWatcher();

watchers.push(watcher);

return watcher;

}),

};

(globalThis as Record<PropertyKey, unknown>)[Symbol.for("openclaw.test.memoryWatchFactory")] =

result.watchMock;

return result;

});

vi.mock("chokidar", () => ({

}),

}));

type MemoryIndexModule = typeof import("./index.js");

type MemoryEmbeddingProvidersModule =

typeof import("openclaw/plugin-sdk/memory-core-host-engine-embeddings");

let getMemorySearchManager: MemoryIndexModule["getMemorySearchManager"];

let closeAllMemorySearchManagers: MemoryIndexModule["closeAllMemorySearchManagers"];

let clearRegistry: MemoryEmbeddingProvidersModule["clearMemoryEmbeddingProviders"];

let registerAdapter: MemoryEmbeddingProvidersModule["registerMemoryEmbeddingProvider"];

import {

clearMemoryEmbeddingProviders as clearRegistry,

registerMemoryEmbeddingProvider as registerAdapter,

} from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";

import {

closeAllMemorySearchManagers,

getMemorySearchManager,

type MemoryIndexManager,

} from "./index.js";

import { registerBuiltInMemoryEmbeddingProviders } from "./provider-adapters.js";

describe("memory watcher config", () => {

let manager: MemoryIndexManager | null = null;

let workspaceDir = "";

let extraDir = "";

beforeAll(async () => {

vi.resetModules();

({ getMemorySearchManager, closeAllMemorySearchManagers } = await import("./index.js"));

({

clearMemoryEmbeddingProviders: clearRegistry,

registerMemoryEmbeddingProvider: registerAdapter,

} = await import("openclaw/plugin-sdk/memory-core-host-engine-embeddings"));

});

beforeEach(async () => {

vi.clearAllMocks();

clearRegistry();

registerBuiltInMemoryEmbeddingProviders({ registerMemoryEmbeddingProvider: registerAdapter });

});

afterAll(() => {

Reflect.deleteProperty(globalThis, Symbol.for("openclaw.test.memoryWatchFactory"));

});

afterEach(async () => {

vi.useRealTimers();

watchMock.mockClear();

}

});

afterAll(() => {

vi.resetModules();

});

async function setupWatcherWorkspace(seedFile: { name: string; contents: string }) {

workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-memory-watch-"));

extraDir = path.join(workspaceDir, "extra");

},

};

return {

memory: { backend: "builtin" },

agents: {

defaults,

list: [{ id: "main", default: true }],

if (!result.manager) {

throw new Error("manager missing");

}

expect(result.manager.status().backend).toBe("builtin");

expect(result.manager.status().sources).toContain("memory");

manager = result.manager as unknown as MemoryIndexManager;

}