cognitive-core 0.2.0 → 0.2.2

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

@@ -1,209 +0,0 @@
-/**
- * Tests for change detection and quarantine
- *
- * Note: Shadow copy system was removed in favor of last-write-wins.
- * Only quarantine functions remain for manual review when needed.
- */
-
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-
-import {
-  detectChanges,
-  quarantineConflict,
-  listQuarantinedConflicts,
-  getConflictsDir,
-} from "../conflicts.js";
-import { initCentralRepo } from "../central.js";
-import { saveSyncState, computeFileHash } from "../state.js";
-import { saveConfig } from "../../config.js";
-
-describe("conflicts", () => {
-  let tempDir: string;
-  let localDir: string;
-  let centralRepo: string;
-  let remotePath: string;
-
-  beforeEach(async () => {
-    // Create temp directories
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-conflicts-test-"));
-    localDir = path.join(tempDir, "local");
-    centralRepo = path.join(tempDir, "central");
-    remotePath = path.join(centralRepo, "test-project");
-
-    // Set up directories
-    await fs.mkdir(localDir, { recursive: true });
-    await fs.mkdir(path.join(localDir, ".minimem"), { recursive: true });
-    await fs.mkdir(path.join(localDir, "memory"), { recursive: true });
-    await fs.mkdir(remotePath, { recursive: true });
-    await fs.mkdir(path.join(remotePath, "memory"), { recursive: true });
-
-    // Initialize central repo
-    await initCentralRepo(centralRepo);
-
-    // Write MEMORY.md to both
-    await fs.writeFile(path.join(localDir, "MEMORY.md"), "# Local Memory\n");
-    await fs.writeFile(path.join(remotePath, "MEMORY.md"), "# Remote Memory\n");
-
-    // Configure sync
-    const config = {
-      sync: {
-        enabled: true,
-        path: "test-project",
-      },
-    };
-    await saveConfig(localDir, config);
-
-    // Set up XDG config with central repo path
-    const xdgDir = path.join(tempDir, "xdg-config");
-    await fs.mkdir(xdgDir, { recursive: true });
-    process.env.XDG_CONFIG_HOME = xdgDir;
-    await fs.mkdir(path.join(xdgDir, "minimem"), { recursive: true });
-    await fs.writeFile(
-      path.join(xdgDir, "minimem", "config.json"),
-      JSON.stringify({ centralRepo }, null, 2)
-    );
-  });
-
-  afterEach(async () => {
-    delete process.env.XDG_CONFIG_HOME;
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("quarantine", () => {
-    it("should quarantine file versions for manual review", async () => {
-      const localContent = "Local version";
-      const remoteContent = "Remote version";
-
-      const conflictDir = await quarantineConflict(
-        localDir,
-        "MEMORY.md",
-        localContent,
-        remoteContent
-      );
-
-      const files = await fs.readdir(conflictDir);
-      expect(files.includes("MEMORY.md.local")).toBeTruthy();
-      expect(files.includes("MEMORY.md.remote")).toBeTruthy();
-
-      const local = await fs.readFile(path.join(conflictDir, "MEMORY.md.local"), "utf-8");
-      expect(local).toBe(localContent);
-    });
-
-    it("should handle null versions", async () => {
-      const conflictDir = await quarantineConflict(
-        localDir,
-        "MEMORY.md",
-        "Local only",
-        null
-      );
-
-      const files = await fs.readdir(conflictDir);
-      expect(files.includes("MEMORY.md.local")).toBeTruthy();
-      expect(!files.includes("MEMORY.md.remote")).toBeTruthy();
-    });
-
-    it("should list quarantined file versions", async () => {
-      await quarantineConflict(localDir, "MEMORY.md", "Local", "Remote");
-      await new Promise((r) => setTimeout(r, 50)); // Slight delay for unique timestamp
-      await quarantineConflict(localDir, "memory/file.md", "Local 2", "Remote 2");
-
-      const conflicts = await listQuarantinedConflicts(localDir);
-
-      expect(conflicts.length >= 2).toBeTruthy();
-      expect(conflicts.some((c) => c.files.includes("MEMORY.md"))).toBeTruthy();
-      expect(conflicts.some((c) => c.files.includes("memory/file.md"))).toBeTruthy();
-    });
-
-    it("should return empty array when no quarantined files", async () => {
-      const conflicts = await listQuarantinedConflicts(localDir);
-      expect(conflicts.length).toBe(0);
-    });
-
-    it("should create conflicts directory path correctly", () => {
-      const conflictsDir = getConflictsDir(localDir);
-      expect(conflictsDir).toBe(path.join(localDir, ".minimem", "conflicts"));
-    });
-  });
-
-  describe("detectChanges", () => {
-    it("should detect unchanged files", async () => {
-      // Same content in both
-      await fs.writeFile(path.join(localDir, "MEMORY.md"), "Same content");
-      await fs.writeFile(path.join(remotePath, "MEMORY.md"), "Same content");
-
-      // Set up sync state with matching hash
-      const hash = await computeFileHash(path.join(localDir, "MEMORY.md"));
-      const state = {
-        version: 2,
-        centralPath: "test-project",
-        lastSync: new Date().toISOString(),
-        files: {
-          "MEMORY.md": {
-            localHash: hash,
-            remoteHash: hash,
-            lastModified: new Date().toISOString(),
-          },
-        },
-      };
-      await saveSyncState(localDir, state);
-
-      const result = await detectChanges(localDir);
-
-      expect(result.summary.unchanged).toBe(1);
-      expect(result.changes.length).toBe(0);
-    });
-
-    it("should detect local-only changes", async () => {
-      // Local has different content
-      await fs.writeFile(path.join(localDir, "MEMORY.md"), "Local change");
-      await fs.writeFile(path.join(remotePath, "MEMORY.md"), "Original");
-
-      const result = await detectChanges(localDir);
-
-      expect(result.summary.localModified).toBe(1);
-    });
-
-    it("should detect remote-only files", async () => {
-      // Remove local file, keep remote
-      await fs.unlink(path.join(localDir, "MEMORY.md"));
-
-      const result = await detectChanges(localDir);
-
-      expect(result.summary.remoteOnly >= 1).toBeTruthy();
-    });
-
-    it("should detect differences when both changed", async () => {
-      // Both have different content
-      await fs.writeFile(path.join(localDir, "MEMORY.md"), "Local change");
-      await fs.writeFile(path.join(remotePath, "MEMORY.md"), "Remote change");
-
-      const result = await detectChanges(localDir);
-
-      // With 2-way comparison, different content = local-modified
-      expect(result.summary.localModified).toBe(1);
-    });
-
-    it("should detect new local files", async () => {
-      await fs.writeFile(path.join(localDir, "memory", "new-file.md"), "New content");
-
-      const result = await detectChanges(localDir);
-
-      expect(result.summary.localOnly >= 1).toBeTruthy();
-    });
-
-    it("should detect new remote files", async () => {
-      await fs.writeFile(path.join(remotePath, "memory", "new-remote.md"), "Remote content");
-
-      const result = await detectChanges(localDir);
-
-      expect(result.summary.remoteOnly >= 1).toBeTruthy();
-    });
-  });
-});

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

@@ -1,118 +0,0 @@
-/**
- * Tests for daemon module
- */
-
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-
-import {
-  getDaemonDir,
-  getPidFilePath,
-  getDaemonLogPath,
-  isDaemonRunning,
-  getDaemonStatus,
-} from "../daemon.js";
-
-describe("Daemon", () => {
-  let originalHome: string | undefined;
-  let tempHome: string;
-
-  beforeEach(async () => {
-    // Create temp home directory
-    tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-daemon-test-"));
-    originalHome = process.env.HOME;
-    process.env.HOME = tempHome;
-  });
-
-  afterEach(async () => {
-    process.env.HOME = originalHome;
-    try {
-      await fs.rm(tempHome, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("getDaemonDir", () => {
-    it("should return path in home directory", () => {
-      const dir = getDaemonDir();
-      expect(dir.includes(".minimem")).toBeTruthy();
-      expect(dir.startsWith(tempHome)).toBeTruthy();
-    });
-  });
-
-  describe("getPidFilePath", () => {
-    it("should return path to daemon.pid", () => {
-      const pidPath = getPidFilePath();
-      expect(pidPath.endsWith("daemon.pid")).toBeTruthy();
-      expect(pidPath.includes(".minimem")).toBeTruthy();
-    });
-  });
-
-  describe("getDaemonLogPath", () => {
-    it("should return path to daemon.log", () => {
-      const logPath = getDaemonLogPath();
-      expect(logPath.endsWith("daemon.log")).toBeTruthy();
-      expect(logPath.includes(".minimem")).toBeTruthy();
-    });
-  });
-
-  describe("isDaemonRunning", () => {
-    it("should return false when no PID file exists", async () => {
-      const running = await isDaemonRunning();
-      expect(running).toBe(false);
-    });
-
-    it("should return false when PID file has invalid content", async () => {
-      const daemonDir = getDaemonDir();
-      await fs.mkdir(daemonDir, { recursive: true });
-      await fs.writeFile(getPidFilePath(), "not-a-number");
-
-      const running = await isDaemonRunning();
-      expect(running).toBe(false);
-    });
-
-    it("should return false when process is not running", async () => {
-      const daemonDir = getDaemonDir();
-      await fs.mkdir(daemonDir, { recursive: true });
-      // Use a PID that definitely doesn't exist
-      await fs.writeFile(getPidFilePath(), "999999999");
-
-      const running = await isDaemonRunning();
-      expect(running).toBe(false);
-
-      // PID file should be cleaned up
-      const exists = await fs.access(getPidFilePath()).then(() => true).catch(() => false);
-      expect(exists).toBe(false);
-    });
-
-    it("should return true for current process PID", async () => {
-      const daemonDir = getDaemonDir();
-      await fs.mkdir(daemonDir, { recursive: true });
-      await fs.writeFile(getPidFilePath(), String(process.pid));
-
-      const running = await isDaemonRunning();
-      expect(running).toBe(true);
-    });
-  });
-
-  describe("getDaemonStatus", () => {
-    it("should return not running when no daemon", async () => {
-      const status = await getDaemonStatus();
-      expect(status.running).toBe(false);
-      expect(status.pid).toBe(undefined);
-    });
-
-    it("should return running with PID when daemon is running", async () => {
-      const daemonDir = getDaemonDir();
-      await fs.mkdir(daemonDir, { recursive: true });
-      await fs.writeFile(getPidFilePath(), String(process.pid));
-
-      const status = await getDaemonStatus();
-      expect(status.running).toBe(true);
-      expect(status.pid).toBe(process.pid);
-    });
-  });
-});

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

@@ -1,207 +0,0 @@
-/**
- * Tests for directory type detection
- *
- * Simplified to two types:
- * - project-bound: inside git repo (synced via project's git)
- * - standalone: uses minimem sync or not in git (default)
- */
-
-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 {
-  detectDirectoryType,
-  isInsideGitRepo,
-  getGitRoot,
-  hasSyncConfig,
-  getDirectoryInfo,
-} from "../detection.js";
-
-describe("Directory Type Detection", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-detection-test-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("isInsideGitRepo", () => {
-    it("should return false for directory without .git", async () => {
-      const result = await isInsideGitRepo(tempDir);
-      expect(result).toBe(false);
-    });
-
-    it("should return true for directory with .git", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      const result = await isInsideGitRepo(tempDir);
-      expect(result).toBe(true);
-    });
-
-    it("should return true for subdirectory of git repo", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      const subDir = path.join(tempDir, "sub", "deep");
-      await fs.mkdir(subDir, { recursive: true });
-
-      const result = await isInsideGitRepo(subDir);
-      expect(result).toBe(true);
-    });
-
-    it("should handle .git as file (worktrees)", async () => {
-      await fs.writeFile(path.join(tempDir, ".git"), "gitdir: /path/to/git");
-      const result = await isInsideGitRepo(tempDir);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe("getGitRoot", () => {
-    it("should return undefined for non-git directory", async () => {
-      const result = await getGitRoot(tempDir);
-      expect(result).toBe(undefined);
-    });
-
-    it("should return git root for git directory", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      const result = await getGitRoot(tempDir);
-      expect(result).toBe(tempDir);
-    });
-
-    it("should return git root from subdirectory", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      const subDir = path.join(tempDir, "sub", "deep");
-      await fs.mkdir(subDir, { recursive: true });
-
-      const result = await getGitRoot(subDir);
-      expect(result).toBe(tempDir);
-    });
-  });
-
-  describe("hasSyncConfig", () => {
-    it("should return false when no config exists", async () => {
-      const result = await hasSyncConfig(tempDir);
-      expect(result).toBe(false);
-    });
-
-    it("should return false when config has no sync section", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ embedding: { provider: "auto" } })
-      );
-
-      const result = await hasSyncConfig(tempDir);
-      expect(result).toBe(false);
-    });
-
-    it("should return true when sync.enabled is true", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { enabled: true } })
-      );
-
-      const result = await hasSyncConfig(tempDir);
-      expect(result).toBe(true);
-    });
-
-    it("should return true when sync.path is set", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { path: "myproject/" } })
-      );
-
-      const result = await hasSyncConfig(tempDir);
-      expect(result).toBe(true);
-    });
-
-    it("should return false when sync.enabled is false and no path", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { enabled: false } })
-      );
-
-      const result = await hasSyncConfig(tempDir);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("detectDirectoryType", () => {
-    it("should detect standalone (no git, no sync)", async () => {
-      const result = await detectDirectoryType(tempDir);
-      expect(result).toBe("standalone");
-    });
-
-    it("should detect project-bound (git, no sync)", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-
-      const result = await detectDirectoryType(tempDir);
-      expect(result).toBe("project-bound");
-    });
-
-    it("should detect standalone (no git, sync enabled)", async () => {
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { enabled: true, path: "test/" } })
-      );
-
-      const result = await detectDirectoryType(tempDir);
-      expect(result).toBe("standalone");
-    });
-
-    it("should detect standalone when both git and sync enabled (sync takes precedence)", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { enabled: true, path: "test/" } })
-      );
-
-      const result = await detectDirectoryType(tempDir);
-      // Sync config takes precedence - directory uses minimem sync
-      expect(result).toBe("standalone");
-    });
-  });
-
-  describe("getDirectoryInfo", () => {
-    it("should return full info for directory with both git and sync", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-      await fs.mkdir(path.join(tempDir, ".minimem"), { recursive: true });
-      await fs.writeFile(
-        path.join(tempDir, ".minimem", "config.json"),
-        JSON.stringify({ sync: { enabled: true, path: "test/" } })
-      );
-
-      const info = await getDirectoryInfo(tempDir);
-
-      // Sync config takes precedence
-      expect(info.type).toBe("standalone");
-      expect(info.gitRoot).toBe(tempDir);
-      expect(info.hasSyncConfig).toBe(true);
-    });
-
-    it("should return undefined gitRoot for non-git directory", async () => {
-      const info = await getDirectoryInfo(tempDir);
-
-      expect(info.type).toBe("standalone");
-      expect(info.gitRoot).toBe(undefined);
-      expect(info.hasSyncConfig).toBe(false);
-    });
-
-    it("should return project-bound for git-only directory", async () => {
-      await fs.mkdir(path.join(tempDir, ".git"));
-
-      const info = await getDirectoryInfo(tempDir);
-
-      expect(info.type).toBe("project-bound");
-      expect(info.gitRoot).toBe(tempDir);
-      expect(info.hasSyncConfig).toBe(false);
-    });
-  });
-});