cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,363 @@
+/**
+ * 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

@@ -0,0 +1,255 @@
+/**
+ * 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();
+    });
+  });
+});