cognitive-core 0.2.1 → 0.2.2

package/references/minimem/src/cli/sync/__tests__/registry.test.ts

@@ -1,363 +0,0 @@
-/**
- * Tests for registry system
- */
-
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import {
-  createEmptyRegistry,
-  readRegistry,
-  writeRegistry,
-  checkCollision,
-  addMapping,
-  removeMapping,
-  findMapping,
-  getMachineMappings,
-  updateLastSync,
-  normalizeRepoPath,
-  compressPath,
-  normalizePath,
-  type Registry,
-} from "../registry.js";
-
-describe("Registry System", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-registry-test-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("createEmptyRegistry", () => {
-    it("should create registry with empty mappings", () => {
-      const registry = createEmptyRegistry();
-      expect(registry.version).toBe(1);
-      expect(registry.mappings).toEqual([]);
-    });
-  });
-
-  describe("readRegistry / writeRegistry", () => {
-    it("should return empty registry when file does not exist", async () => {
-      const registry = await readRegistry(tempDir);
-      expect(registry.mappings).toEqual([]);
-    });
-
-    it("should read and write registry correctly", async () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "test-machine-1234",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      await writeRegistry(tempDir, registry);
-      const loaded = await readRegistry(tempDir);
-
-      expect(loaded.version).toBe(1);
-      expect(loaded.mappings.length).toBe(1);
-      expect(loaded.mappings[0].path).toBe("global/");
-      expect(loaded.mappings[0].machineId).toBe("test-machine-1234");
-    });
-
-    it("should handle malformed registry file", async () => {
-      await fs.writeFile(
-        path.join(tempDir, ".minimem-registry.json"),
-        "{ invalid json"
-      );
-
-      const registry = await readRegistry(tempDir);
-      expect(registry.mappings).toEqual([]);
-    });
-  });
-
-  describe("normalizeRepoPath", () => {
-    it("should add trailing slash", () => {
-      expect(normalizeRepoPath("global")).toBe("global/");
-    });
-
-    it("should preserve existing trailing slash", () => {
-      expect(normalizeRepoPath("global/")).toBe("global/");
-    });
-
-    it("should remove multiple trailing slashes", () => {
-      expect(normalizeRepoPath("global///")).toBe("global/");
-    });
-
-    it("should handle root path", () => {
-      expect(normalizeRepoPath("/")).toBe("/");
-    });
-  });
-
-  describe("compressPath / normalizePath", () => {
-    it("should compress home directory to ~", () => {
-      const homePath = path.join(os.homedir(), "test", "path");
-      const compressed = compressPath(homePath);
-      expect(compressed).toBe("~/test/path");
-    });
-
-    it("should expand ~ to home directory", () => {
-      const expanded = normalizePath("~/test/path");
-      expect(expanded).toBe(path.join(os.homedir(), "test", "path"));
-    });
-
-    it("should handle paths without home", () => {
-      const absPath = "/tmp/test/path";
-      expect(compressPath(absPath)).toBe(absPath);
-      expect(normalizePath(absPath)).toBe(absPath);
-    });
-  });
-
-  describe("checkCollision", () => {
-    it("should return 'none' for new path", () => {
-      const registry = createEmptyRegistry();
-      const result = checkCollision(registry, "newpath/", "/tmp/test", "machine-1");
-      expect(result).toBe("none");
-    });
-
-    it("should return 'same-machine' for existing path on same machine", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const result = checkCollision(registry, "global/", "/other/path", "machine-1");
-      expect(result).toBe("same-machine");
-    });
-
-    it("should return 'collision' for existing path on different machine", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const result = checkCollision(registry, "global/", "/other/path", "machine-2");
-      expect(result).toBe("collision");
-    });
-
-    it("should handle path normalization in collision check", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      // Without trailing slash should still match
-      const result = checkCollision(registry, "global", "/other/path", "machine-2");
-      expect(result).toBe("collision");
-    });
-  });
-
-  describe("addMapping", () => {
-    it("should add new mapping", () => {
-      const registry = createEmptyRegistry();
-      const updated = addMapping(registry, {
-        path: "global/",
-        localPath: "~/.minimem",
-        machineId: "machine-1",
-        lastSync: "2024-01-15T10:30:00.000Z",
-      });
-
-      expect(updated.mappings.length).toBe(1);
-      expect(updated.mappings[0].path).toBe("global/");
-    });
-
-    it("should update existing mapping for same machine", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      // Use absolute path that will be compressed to ~/new-path
-      const newPath = path.join(os.homedir(), "new-path");
-      const updated = addMapping(registry, {
-        path: "global/",
-        localPath: newPath,
-        machineId: "machine-1",
-        lastSync: "2024-01-16T10:30:00.000Z",
-      });
-
-      expect(updated.mappings.length).toBe(1);
-      expect(updated.mappings[0].localPath).toBe("~/new-path");
-    });
-
-    it("should compress local paths", () => {
-      const registry = createEmptyRegistry();
-      const homePath = path.join(os.homedir(), "test");
-      const updated = addMapping(registry, {
-        path: "test/",
-        localPath: homePath,
-        machineId: "machine-1",
-        lastSync: "2024-01-15T10:30:00.000Z",
-      });
-
-      expect(updated.mappings[0].localPath).toBe("~/test");
-    });
-  });
-
-  describe("removeMapping", () => {
-    it("should remove existing mapping", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-          {
-            path: "work/",
-            localPath: "~/work",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const updated = removeMapping(registry, "global/", "machine-1");
-      expect(updated.mappings.length).toBe(1);
-      expect(updated.mappings[0].path).toBe("work/");
-    });
-
-    it("should not affect other machines' mappings", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-2",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const updated = removeMapping(registry, "global/", "machine-1");
-      expect(updated.mappings.length).toBe(1);
-      expect(updated.mappings[0].machineId).toBe("machine-2");
-    });
-  });
-
-  describe("findMapping", () => {
-    it("should find existing mapping", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const found = findMapping(registry, "global/", "machine-1");
-      expect(found).toBeTruthy();
-      expect(found!.localPath).toBe("~/.minimem");
-    });
-
-    it("should return undefined for non-existent mapping", () => {
-      const registry = createEmptyRegistry();
-      const found = findMapping(registry, "global/", "machine-1");
-      expect(found).toBeUndefined();
-    });
-  });
-
-  describe("getMachineMappings", () => {
-    it("should return all mappings for a machine", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-          {
-            path: "work/",
-            localPath: "~/work",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-          {
-            path: "other/",
-            localPath: "~/other",
-            machineId: "machine-2",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const mappings = getMachineMappings(registry, "machine-1");
-      expect(mappings.length).toBe(2);
-    });
-  });
-
-  describe("updateLastSync", () => {
-    it("should update lastSync timestamp", () => {
-      const registry: Registry = {
-        version: 1,
-        mappings: [
-          {
-            path: "global/",
-            localPath: "~/.minimem",
-            machineId: "machine-1",
-            lastSync: "2024-01-15T10:30:00.000Z",
-          },
-        ],
-      };
-
-      const updated = updateLastSync(registry, "global/", "machine-1");
-      expect(updated.mappings[0].lastSync).not.toBe("2024-01-15T10:30:00.000Z");
-      // Should be a valid ISO date
-      const date = new Date(updated.mappings[0].lastSync);
-      expect(isNaN(date.getTime())).toBe(false);
-    });
-  });
-});

package/references/minimem/src/cli/sync/__tests__/state.test.ts

@@ -1,255 +0,0 @@
-/**
- * Tests for sync state tracking
- *
- * Uses simplified 2-way comparison (local vs remote).
- * No lastSyncedHash - conflict resolution is last-write-wins.
- */
-
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, it, expect } from "vitest";
-
-import {
-  createEmptySyncState,
-  loadSyncState,
-  saveSyncState,
-  computeFileHash,
-  computeContentHash,
-  listSyncableFiles,
-  getFileSyncStatus,
-  updateSyncStateAfterSync,
-  removeFileFromSyncState,
-  type SyncState,
-} from "../state.js";
-
-describe("Sync State", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-state-test-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("createEmptySyncState", () => {
-    it("should create empty state with central path", () => {
-      const state = createEmptySyncState("myproject/");
-      expect(state.version).toBe(2);
-      expect(state.lastSync).toBe(null);
-      expect(state.centralPath).toBe("myproject/");
-      expect(state.files).toEqual({});
-    });
-  });
-
-  describe("loadSyncState / saveSyncState", () => {
-    it("should return empty state when file does not exist", async () => {
-      const state = await loadSyncState(tempDir, "test/");
-      expect(state.lastSync).toBe(null);
-      expect(state.files).toEqual({});
-    });
-
-    it("should save and load state correctly", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-
-      const state: SyncState = {
-        version: 2,
-        lastSync: "2024-01-15T10:30:00.000Z",
-        centralPath: "myproject/",
-        files: {
-          "MEMORY.md": {
-            localHash: "abc123",
-            remoteHash: "abc123",
-            lastModified: "2024-01-15T10:30:00.000Z",
-          },
-        },
-      };
-
-      await saveSyncState(tempDir, state);
-      const loaded = await loadSyncState(tempDir, "myproject/");
-
-      expect(loaded.lastSync).toBe("2024-01-15T10:30:00.000Z");
-      expect(loaded.files["MEMORY.md"].localHash).toBe("abc123");
-    });
-
-    it("should migrate v1 state to v2", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-
-      // Write v1 state with lastSyncedHash
-      const v1State = {
-        version: 1,
-        lastSync: "2024-01-15T10:30:00.000Z",
-        centralPath: "myproject/",
-        files: {
-          "MEMORY.md": {
-            localHash: "abc123",
-            remoteHash: "abc123",
-            lastSyncedHash: "abc123",
-            lastModified: "2024-01-15T10:30:00.000Z",
-          },
-        },
-      };
-
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "sync-state.json"),
-        JSON.stringify(v1State, null, 2)
-      );
-
-      const loaded = await loadSyncState(tempDir, "myproject/");
-
-      expect(loaded.version).toBe(2);
-      // lastSyncedHash should be removed during migration
-      expect((loaded.files["MEMORY.md"] as unknown as { lastSyncedHash?: string }).lastSyncedHash).toBeUndefined();
-    });
-  });
-
-  describe("computeFileHash / computeContentHash", () => {
-    it("should compute consistent hash for file", async () => {
-      const filePath = path.join(tempDir, "test.txt");
-      await fs.writeFile(filePath, "Hello, World!");
-
-      const hash1 = await computeFileHash(filePath);
-      const hash2 = await computeFileHash(filePath);
-
-      expect(hash1).toBe(hash2);
-      expect(hash1.length).toBe(64); // SHA-256 hex
-    });
-
-    it("should compute consistent hash for content", () => {
-      const hash1 = computeContentHash("Hello, World!");
-      const hash2 = computeContentHash("Hello, World!");
-
-      expect(hash1).toBe(hash2);
-    });
-
-    it("should produce different hashes for different content", () => {
-      const hash1 = computeContentHash("Hello");
-      const hash2 = computeContentHash("World");
-
-      expect(hash1).not.toBe(hash2);
-    });
-  });
-
-  describe("listSyncableFiles", () => {
-    beforeEach(async () => {
-      // Create test file structure
-      await fs.mkdir(path.join(tempDir, "memory"), { recursive: true });
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(path.join(tempDir, "MEMORY.md"), "# Memory");
-      await fs.writeFile(path.join(tempDir, "memory", "notes.md"), "# Notes");
-      await fs.writeFile(path.join(tempDir, "memory", "draft.txt"), "Draft");
-      await fs.writeFile(path.join(tempDir, ".minimem", "config.json"), "{}");
-      await fs.writeFile(path.join(tempDir, "other.txt"), "Other");
-    });
-
-    it("should list files matching include patterns", async () => {
-      const files = await listSyncableFiles(
-        tempDir,
-        ["MEMORY.md", "memory/**/*.md"],
-        []
-      );
-
-      expect(files.includes("MEMORY.md")).toBeTruthy();
-      expect(files.includes("memory/notes.md")).toBeTruthy();
-      expect(!files.includes("memory/draft.txt")).toBeTruthy(); // .txt not matched
-      expect(!files.includes("other.txt")).toBeTruthy(); // not matched
-    });
-
-    it("should exclude .minimem directory", async () => {
-      const files = await listSyncableFiles(tempDir, ["**/*"], []);
-
-      expect(!files.some((f) => f.includes(".minimem"))).toBeTruthy();
-    });
-
-    it("should apply exclude patterns", async () => {
-      const files = await listSyncableFiles(
-        tempDir,
-        ["**/*.md"],
-        ["memory/**"]
-      );
-
-      expect(files.includes("MEMORY.md")).toBeTruthy();
-      expect(!files.includes("memory/notes.md")).toBeTruthy(); // excluded
-    });
-
-    it("should return sorted list", async () => {
-      const files = await listSyncableFiles(
-        tempDir,
-        ["MEMORY.md", "memory/**/*.md"],
-        []
-      );
-
-      const sorted = [...files].sort();
-      expect(files).toEqual(sorted);
-    });
-  });
-
-  describe("getFileSyncStatus", () => {
-    // 2-way comparison: only localHash and remoteHash
-
-    it("should return unchanged when hashes match", () => {
-      const status = getFileSyncStatus("abc", "abc");
-      expect(status).toBe("unchanged");
-    });
-
-    it("should return local-modified when hashes differ", () => {
-      const status = getFileSyncStatus("local", "remote");
-      expect(status).toBe("local-modified");
-    });
-
-    it("should return local-only for file only on local", () => {
-      const status = getFileSyncStatus("abc", null);
-      expect(status).toBe("local-only");
-    });
-
-    it("should return remote-only for file only on remote", () => {
-      const status = getFileSyncStatus(null, "abc");
-      expect(status).toBe("remote-only");
-    });
-
-    it("should return unchanged when both null", () => {
-      const status = getFileSyncStatus(null, null);
-      expect(status).toBe("unchanged");
-    });
-  });
-
-  describe("updateSyncStateAfterSync", () => {
-    it("should update file entry and lastSync", () => {
-      const state = createEmptySyncState("test/");
-      const updated = updateSyncStateAfterSync(state, "MEMORY.md", "newhash");
-
-      expect(updated.lastSync).toBeTruthy();
-      expect(updated.files["MEMORY.md"].localHash).toBe("newhash");
-      expect(updated.files["MEMORY.md"].remoteHash).toBe("newhash");
-    });
-  });
-
-  describe("removeFileFromSyncState", () => {
-    it("should remove file entry", () => {
-      const state: SyncState = {
-        version: 2,
-        lastSync: "2024-01-15T10:30:00.000Z",
-        centralPath: "test/",
-        files: {
-          "MEMORY.md": {
-            localHash: "abc",
-            remoteHash: "abc",
-            lastModified: "2024-01-15T10:30:00.000Z",
-          },
-          "notes.md": {
-            localHash: "def",
-            remoteHash: "def",
-            lastModified: "2024-01-15T10:30:00.000Z",
-          },
-        },
-      };
-
-      const updated = removeFileFromSyncState(state, "MEMORY.md");
-
-      expect(!("MEMORY.md" in updated.files)).toBeTruthy();
-      expect("notes.md" in updated.files).toBeTruthy();
-    });
-  });
-});