cognitive-core 0.0.2 → 0.1.2

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

@@ -0,0 +1,193 @@
+/**
+ * Tests for registry validation
+ */
+
+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 { validateRegistry, formatValidationResult } from "../validation.js";
+import { initCentralRepo } from "../central.js";
+import { writeRegistry, createEmptyRegistry, addMapping, type Registry } from "../registry.js";
+
+describe("Registry Validation", () => {
+  let tempDir: string;
+  let centralRepo: string;
+  let localDir: string;
+  let xdgDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-validation-test-"));
+    centralRepo = path.join(tempDir, "central");
+    localDir = path.join(tempDir, "local");
+    xdgDir = path.join(tempDir, "xdg-config");
+
+    await fs.mkdir(localDir, { recursive: true });
+    await fs.mkdir(path.join(localDir, ".minimem"), { recursive: true });
+    await fs.mkdir(xdgDir, { recursive: true });
+
+    // Initialize central repo
+    await initCentralRepo(centralRepo);
+
+    // Set up XDG config
+    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, machineId: "test-machine-1234" }, null, 2)
+    );
+  });
+
+  afterEach(async () => {
+    delete process.env.XDG_CONFIG_HOME;
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("validateRegistry", () => {
+    it("should return valid for empty registry", async () => {
+      const result = await validateRegistry();
+
+      expect(result.valid).toBe(true);
+      expect(result.stats.totalMappings).toBe(0);
+      expect(result.issues.length).toBe(0);
+    });
+
+    it("should return valid for registry with active mappings", async () => {
+      const registry = createEmptyRegistry();
+      const updated = addMapping(registry, {
+        path: "test-project",
+        localPath: localDir,
+        machineId: "test-machine-1234",
+        lastSync: new Date().toISOString(),
+      });
+      await writeRegistry(centralRepo, updated);
+
+      const result = await validateRegistry();
+
+      expect(result.valid).toBe(true);
+      expect(result.stats.totalMappings).toBe(1);
+      expect(result.stats.activeMappings).toBe(1);
+    });
+
+    it("should detect path collisions", async () => {
+      const registry = createEmptyRegistry();
+      // Same path, different machines
+      registry.mappings.push({
+        path: "shared-project",
+        localPath: "/path/on/machine1",
+        machineId: "machine-1",
+        lastSync: new Date().toISOString(),
+      });
+      registry.mappings.push({
+        path: "shared-project",
+        localPath: "/path/on/machine2",
+        machineId: "machine-2",
+        lastSync: new Date().toISOString(),
+      });
+      await writeRegistry(centralRepo, registry);
+
+      const result = await validateRegistry();
+
+      expect(result.valid).toBe(false);
+      expect(result.stats.collisions).toBe(1);
+      expect(result.issues.some((i) => i.type === "collision")).toBeTruthy();
+    });
+
+    it("should detect stale mappings", async () => {
+      const registry = createEmptyRegistry();
+      const oldDate = new Date();
+      oldDate.setDate(oldDate.getDate() - 60); // 60 days ago
+
+      registry.mappings.push({
+        path: "old-project",
+        localPath: "/path/to/old",
+        machineId: "old-machine",
+        lastSync: oldDate.toISOString(),
+      });
+      await writeRegistry(centralRepo, registry);
+
+      const result = await validateRegistry();
+
+      expect(result.stats.staleMappings).toBe(1);
+      expect(result.issues.some((i) => i.type === "stale")).toBeTruthy();
+    });
+
+    it("should detect missing local directories", async () => {
+      // Read the machineId that was set in XDG config
+      const { loadXdgConfig } = await import("../../config.js");
+      const xdgConfig = await loadXdgConfig();
+      const currentMachineId = xdgConfig.machineId;
+
+      const registry = createEmptyRegistry();
+      registry.mappings.push({
+        path: "missing-project",
+        localPath: path.join(tempDir, "nonexistent"),
+        machineId: currentMachineId!, // Current machine
+        lastSync: new Date().toISOString(),
+      });
+      await writeRegistry(centralRepo, registry);
+
+      const result = await validateRegistry();
+
+      expect(result.stats.missingDirs).toBe(1);
+      expect(result.issues.some((i) => i.type === "missing")).toBeTruthy();
+    });
+
+    it("should not check local dirs for other machines", async () => {
+      const registry = createEmptyRegistry();
+      registry.mappings.push({
+        path: "other-project",
+        localPath: "/nonexistent/path",
+        machineId: "other-machine", // Different machine
+        lastSync: new Date().toISOString(),
+      });
+      await writeRegistry(centralRepo, registry);
+
+      const result = await validateRegistry();
+
+      // Should not report missing dir since it's on a different machine
+      expect(result.stats.missingDirs).toBe(0);
+    });
+  });
+
+  describe("formatValidationResult", () => {
+    it("should format valid result", async () => {
+      const result = await validateRegistry();
+      const formatted = formatValidationResult(result);
+
+      expect(formatted.includes("Registry Validation Results")).toBeTruthy();
+      expect(formatted.includes("No issues found")).toBeTruthy();
+      expect(formatted.includes("valid")).toBeTruthy();
+    });
+
+    it("should format result with issues", async () => {
+      // Create a collision
+      const registry = createEmptyRegistry();
+      registry.mappings.push({
+        path: "shared",
+        localPath: "/path1",
+        machineId: "machine-1",
+        lastSync: new Date().toISOString(),
+      });
+      registry.mappings.push({
+        path: "shared",
+        localPath: "/path2",
+        machineId: "machine-2",
+        lastSync: new Date().toISOString(),
+      });
+      await writeRegistry(centralRepo, registry);
+
+      const result = await validateRegistry();
+      const formatted = formatValidationResult(result);
+
+      expect(formatted.includes("Issues:")).toBeTruthy();
+      expect(formatted.includes("ERROR")).toBeTruthy();
+      expect(formatted.includes("collision") || formatted.includes("multiple machines")).toBeTruthy();
+    });
+  });
+});

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

@@ -0,0 +1,178 @@
+/**
+ * Tests for file watcher
+ *
+ * Note: File event detection tests are skipped due to chokidar timing issues in test environments.
+ * The core watcher functionality is tested via creation, cleanup, and listener management.
+ */
+
+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 { createFileWatcher, createMultiDirWatcher, type FileChange } from "../watcher.js";
+
+describe("File Watcher", () => {
+  let tempDir: string;
+  let memoryDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-watcher-test-"));
+    memoryDir = tempDir;
+    await fs.mkdir(path.join(memoryDir, "memory"), { recursive: true });
+    await fs.writeFile(path.join(memoryDir, "MEMORY.md"), "# Memory\n");
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("createFileWatcher", () => {
+    it("should create watcher and become ready", async () => {
+      const watcher = createFileWatcher(memoryDir, { debounceMs: 100 });
+
+      // Wait for ready
+      await new Promise<void>((resolve) => {
+        const check = () => {
+          if (watcher.ready) {
+            resolve();
+          } else {
+            setTimeout(check, 50);
+          }
+        };
+        check();
+      });
+
+      expect(watcher.ready).toBe(true);
+      await watcher.close();
+    });
+
+    it("should clean up on close", async () => {
+      const watcher = createFileWatcher(memoryDir, { debounceMs: 100 });
+
+      await new Promise<void>((resolve) => {
+        const check = () => {
+          if (watcher.ready) resolve();
+          else setTimeout(check, 50);
+        };
+        check();
+      });
+
+      let changeCount = 0;
+      watcher.on("changes", () => {
+        changeCount++;
+      });
+
+      await watcher.close();
+
+      // Changes after close should not trigger events
+      await fs.writeFile(path.join(memoryDir, "MEMORY.md"), "# After close\n");
+      await new Promise((r) => setTimeout(r, 200));
+
+      expect(changeCount).toBe(0);
+    });
+
+    it("should allow adding and removing listeners", async () => {
+      const watcher = createFileWatcher(memoryDir, { debounceMs: 100 });
+
+      await new Promise<void>((resolve) => {
+        const check = () => {
+          if (watcher.ready) resolve();
+          else setTimeout(check, 50);
+        };
+        check();
+      });
+
+      let changeCount = 0;
+      const listener = () => {
+        changeCount++;
+      };
+
+      watcher.on("changes", listener);
+      watcher.off("changes", listener);
+
+      // No listener should be called
+      await watcher.close();
+    });
+
+    it("should accept custom options", async () => {
+      const watcher = createFileWatcher(memoryDir, {
+        debounceMs: 500,
+        include: ["*.md", "docs/**/*.md"],
+        exclude: ["temp/**"],
+        usePolling: false,
+        pollInterval: 2000,
+      });
+
+      await new Promise<void>((resolve) => {
+        const check = () => {
+          if (watcher.ready) resolve();
+          else setTimeout(check, 50);
+        };
+        check();
+      });
+
+      expect(watcher.ready).toBe(true);
+      await watcher.close();
+    });
+  });
+
+  describe("createMultiDirWatcher", () => {
+    it("should watch multiple directories", async () => {
+      const dir2 = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-watcher-test2-"));
+      await fs.mkdir(path.join(dir2, "memory"), { recursive: true });
+      await fs.writeFile(path.join(dir2, "MEMORY.md"), "# Memory 2\n");
+
+      try {
+        const watcher = createMultiDirWatcher([memoryDir, dir2], { debounceMs: 100 });
+
+        await new Promise<void>((resolve) => {
+          const check = () => {
+            if (watcher.ready) resolve();
+            else setTimeout(check, 50);
+          };
+          check();
+        });
+
+        expect(watcher.ready).toBe(true);
+        await watcher.close();
+      } finally {
+        await fs.rm(dir2, { recursive: true, force: true });
+      }
+    });
+
+    it("should close all watchers", async () => {
+      const dir2 = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-watcher-test3-"));
+      await fs.mkdir(path.join(dir2, "memory"), { recursive: true });
+
+      try {
+        const watcher = createMultiDirWatcher([memoryDir, dir2], { debounceMs: 100 });
+
+        await new Promise<void>((resolve) => {
+          const check = () => {
+            if (watcher.ready) resolve();
+            else setTimeout(check, 50);
+          };
+          check();
+        });
+
+        let changeCount = 0;
+        watcher.on("changes", () => changeCount++);
+
+        await watcher.close();
+
+        // Changes after close should not trigger events
+        await fs.writeFile(path.join(memoryDir, "MEMORY.md"), "# Changed\n");
+        await new Promise((r) => setTimeout(r, 200));
+
+        expect(changeCount).toBe(0);
+      } finally {
+        await fs.rm(dir2, { recursive: true, force: true });
+      }
+    });
+  });
+});

package/references/minimem/src/cli/sync/central.ts

@@ -0,0 +1,292 @@
+/**
+ * Central repository initialization and management
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execSync } from "node:child_process";
+
+import { expandPath, saveXdgConfig, loadXdgConfig } from "../config.js";
+import {
+  createEmptyRegistry,
+  writeRegistry,
+  readRegistry,
+  getRegistryPath,
+} from "./registry.js";
+import { isInsideGitRepo } from "./detection.js";
+
+const GITIGNORE_CONTENT = `# Minimem sync - ignore database files and temp directories
+*.db
+*.db-journal
+*.db-wal
+*.db-shm
+staging/
+conflicts/
+shadows/
+.DS_Store
+`;
+
+const README_CONTENT = `# Minimem Central Repository
+
+This repository contains synchronized memory files from minimem.
+
+## Structure
+
+Each directory represents a mapped memory location:
+
+\`\`\`
+memories-repo/
+├── global/              # ~/.minimem/
+├── work/                # ~/work/memories/
+└── projects/
+    └── myproject/       # ~/projects/myproject/
+\`\`\`
+
+## Registry
+
+The \`.minimem-registry.json\` file tracks which local directories are mapped to which paths.
+This prevents path collisions when multiple machines sync to the same repository.
+
+## Usage
+
+To sync a local memory directory to this repo:
+
+\`\`\`bash
+minimem config --xdg-global --set centralRepo=<path-to-this-repo>
+minimem sync init --path <directory-name>/
+\`\`\`
+
+## Files
+
+- \`.minimem-registry.json\` - Tracks sync mappings
+- \`.gitignore\` - Ignores database and temp files
+- \`*/MEMORY.md\` - Main memory files
+- \`*/memory/*.md\` - Additional memory files
+`;
+
+export type InitCentralResult = {
+  success: boolean;
+  path: string;
+  created: boolean;
+  message: string;
+};
+
+/**
+ * Check if a path is writable
+ */
+async function isWritable(dirPath: string): Promise<boolean> {
+  try {
+    const testFile = path.join(dirPath, `.minimem-write-test-${Date.now()}`);
+    await fs.writeFile(testFile, "test");
+    await fs.unlink(testFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if git is available
+ */
+function isGitAvailable(): boolean {
+  try {
+    execSync("git --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initialize a git repository
+ */
+async function initGitRepo(dirPath: string): Promise<void> {
+  execSync("git init", { cwd: dirPath, stdio: "pipe" });
+}
+
+/**
+ * Initialize a new central repository or configure an existing one
+ */
+export async function initCentralRepo(
+  repoPath: string
+): Promise<InitCentralResult> {
+  const expandedPath = expandPath(repoPath);
+  const resolvedPath = path.resolve(expandedPath);
+
+  // Check if git is available
+  if (!isGitAvailable()) {
+    return {
+      success: false,
+      path: resolvedPath,
+      created: false,
+      message: "Git is not installed or not available in PATH",
+    };
+  }
+
+  // Check if directory exists
+  let dirExists = false;
+  try {
+    const stat = await fs.stat(resolvedPath);
+    dirExists = stat.isDirectory();
+  } catch {
+    dirExists = false;
+  }
+
+  let created = false;
+
+  if (!dirExists) {
+    // Create new directory
+    try {
+      await fs.mkdir(resolvedPath, { recursive: true });
+      created = true;
+    } catch (error) {
+      return {
+        success: false,
+        path: resolvedPath,
+        created: false,
+        message: `Failed to create directory: ${error}`,
+      };
+    }
+  }
+
+  // Check if writable
+  if (!(await isWritable(resolvedPath))) {
+    return {
+      success: false,
+      path: resolvedPath,
+      created,
+      message: "Directory is not writable",
+    };
+  }
+
+  // Initialize git repo if not already
+  const isGitRepo = await isInsideGitRepo(resolvedPath);
+  if (!isGitRepo) {
+    try {
+      await initGitRepo(resolvedPath);
+    } catch (error) {
+      return {
+        success: false,
+        path: resolvedPath,
+        created,
+        message: `Failed to initialize git repository: ${error}`,
+      };
+    }
+  }
+
+  // Create .gitignore if not exists
+  const gitignorePath = path.join(resolvedPath, ".gitignore");
+  try {
+    await fs.access(gitignorePath);
+  } catch {
+    await fs.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+  }
+
+  // Create registry if not exists
+  const registryPath = getRegistryPath(resolvedPath);
+  try {
+    await fs.access(registryPath);
+  } catch {
+    await writeRegistry(resolvedPath, createEmptyRegistry());
+  }
+
+  // Create README if not exists
+  const readmePath = path.join(resolvedPath, "README.md");
+  try {
+    await fs.access(readmePath);
+  } catch {
+    await fs.writeFile(readmePath, README_CONTENT, "utf-8");
+  }
+
+  // Update global config with central repo path
+  const globalConfig = await loadXdgConfig();
+  globalConfig.centralRepo = repoPath; // Store original (possibly with ~)
+  await saveXdgConfig(globalConfig);
+
+  return {
+    success: true,
+    path: resolvedPath,
+    created,
+    message: created
+      ? "Created new central repository"
+      : "Configured existing directory as central repository",
+  };
+}
+
+/**
+ * Validate an existing central repository
+ */
+export async function validateCentralRepo(repoPath: string): Promise<{
+  valid: boolean;
+  warnings: string[];
+  errors: string[];
+}> {
+  const expandedPath = expandPath(repoPath);
+  const resolvedPath = path.resolve(expandedPath);
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  // Check directory exists
+  try {
+    const stat = await fs.stat(resolvedPath);
+    if (!stat.isDirectory()) {
+      errors.push("Path is not a directory");
+      return { valid: false, warnings, errors };
+    }
+  } catch {
+    errors.push("Directory does not exist");
+    return { valid: false, warnings, errors };
+  }
+
+  // Check if git repo
+  const isGitRepo = await isInsideGitRepo(resolvedPath);
+  if (!isGitRepo) {
+    warnings.push("Not a git repository - sync features may be limited");
+  }
+
+  // Check for registry
+  const registryPath = getRegistryPath(resolvedPath);
+  try {
+    await fs.access(registryPath);
+    // Validate registry content
+    const registry = await readRegistry(resolvedPath);
+    if (!registry.mappings) {
+      warnings.push("Registry file is malformed");
+    }
+  } catch {
+    warnings.push("Registry file is missing - will be created on first sync");
+  }
+
+  // Check for .gitignore
+  const gitignorePath = path.join(resolvedPath, ".gitignore");
+  try {
+    const gitignore = await fs.readFile(gitignorePath, "utf-8");
+    if (!gitignore.includes("*.db")) {
+      warnings.push(".gitignore does not exclude database files");
+    }
+  } catch {
+    warnings.push(".gitignore is missing");
+  }
+
+  // Check if writable
+  if (!(await isWritable(resolvedPath))) {
+    errors.push("Directory is not writable");
+  }
+
+  return {
+    valid: errors.length === 0,
+    warnings,
+    errors,
+  };
+}
+
+/**
+ * Get the configured central repo path
+ */
+export async function getCentralRepoPath(): Promise<string | undefined> {
+  const globalConfig = await loadXdgConfig();
+  if (globalConfig.centralRepo) {
+    return path.resolve(expandPath(globalConfig.centralRepo));
+  }
+  return undefined;
+}