cognitive-core 0.2.1 → 0.2.2

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

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

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

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