cognitive-core 0.2.1 → 0.2.2

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

@@ -1,204 +0,0 @@
-/**
- * Sync change detection
- *
- * Detects differences between local and remote files.
- * With last-write-wins, there are no conflicts - just differences.
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { getSyncConfig } from "../config.js";
-import {
-  listSyncableFiles,
-  getFileHashInfo,
-  getFileSyncStatus,
-  type FileSyncStatus,
-} from "./state.js";
-import { getCentralRepoPath } from "./central.js";
-
-const CONFLICTS_DIR = "conflicts";
-
-export type FileChange = {
-  /** Relative file path */
-  file: string;
-  /** Sync status */
-  status: FileSyncStatus;
-  /** Local file hash (null if missing) */
-  localHash: string | null;
-  /** Remote file hash (null if missing) */
-  remoteHash: string | null;
-};
-
-// Keep FileConflict as an alias for backwards compatibility
-export type FileConflict = FileChange;
-
-export type ChangeDetectionResult = {
-  /** Files that need action */
-  changes: FileChange[];
-  /** Files with no changes */
-  unchanged: string[];
-  /** Summary counts */
-  summary: {
-    unchanged: number;
-    localOnly: number;
-    remoteOnly: number;
-    localModified: number;
-  };
-};
-
-// Keep ConflictDetectionResult as an alias for backwards compatibility
-export type ConflictDetectionResult = ChangeDetectionResult;
-
-/**
- * Get the conflicts directory path (for quarantined files)
- */
-export function getConflictsDir(memoryDir: string): string {
-  return path.join(memoryDir, ".minimem", CONFLICTS_DIR);
-}
-
-/**
- * Quarantine file versions for manual review
- * Saves local and remote versions to conflicts directory
- */
-export async function quarantineConflict(
-  memoryDir: string,
-  filePath: string,
-  localContent: string | Buffer | null,
-  remoteContent: string | Buffer | null
-): Promise<string> {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const conflictDir = path.join(getConflictsDir(memoryDir), timestamp);
-  const flatName = filePath.replace(/\//g, "_");
-
-  await fs.mkdir(conflictDir, { recursive: true });
-
-  if (localContent !== null) {
-    await fs.writeFile(path.join(conflictDir, `${flatName}.local`), localContent);
-  }
-  if (remoteContent !== null) {
-    await fs.writeFile(path.join(conflictDir, `${flatName}.remote`), remoteContent);
-  }
-
-  return conflictDir;
-}
-
-/**
- * List all quarantined file versions
- */
-export async function listQuarantinedConflicts(
-  memoryDir: string
-): Promise<Array<{ timestamp: string; files: string[] }>> {
-  const conflictsDir = getConflictsDir(memoryDir);
-  const conflicts: Array<{ timestamp: string; files: string[] }> = [];
-
-  try {
-    const entries = await fs.readdir(conflictsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const dirPath = path.join(conflictsDir, entry.name);
-        const files = await fs.readdir(dirPath);
-
-        // Extract unique file names (remove .local, .remote suffixes)
-        const uniqueFiles = new Set<string>();
-        for (const file of files) {
-          const baseName = file.replace(/\.(local|remote|base)$/, "");
-          uniqueFiles.add(baseName.replace(/_/g, "/"));
-        }
-
-        conflicts.push({
-          timestamp: entry.name,
-          files: Array.from(uniqueFiles),
-        });
-      }
-    }
-  } catch {
-    // Directory might not exist
-  }
-
-  return conflicts.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-}
-
-/**
- * Detect changes between local and remote
- */
-export async function detectChanges(
-  memoryDir: string
-): Promise<ChangeDetectionResult> {
-  // Get central repo path
-  const centralRepo = await getCentralRepoPath();
-  if (!centralRepo) {
-    throw new Error("No central repository configured");
-  }
-
-  // Get sync config
-  const syncConfig = await getSyncConfig(memoryDir);
-  if (!syncConfig.path) {
-    throw new Error("Directory is not configured for sync");
-  }
-
-  const remotePath = path.join(centralRepo, syncConfig.path);
-
-  // Get file lists
-  const [localFiles, remoteFiles] = await Promise.all([
-    listSyncableFiles(memoryDir, syncConfig.include, syncConfig.exclude),
-    listSyncableFiles(remotePath, syncConfig.include, syncConfig.exclude),
-  ]);
-
-  const allFiles = new Set([...localFiles, ...remoteFiles]);
-
-  const changes: FileChange[] = [];
-  const unchanged: string[] = [];
-  const summary = {
-    unchanged: 0,
-    localOnly: 0,
-    remoteOnly: 0,
-    localModified: 0,
-  };
-
-  for (const file of allFiles) {
-    const localPath = path.join(memoryDir, file);
-    const remoteFilePath = path.join(remotePath, file);
-
-    const [localInfo, remoteInfo] = await Promise.all([
-      getFileHashInfo(localPath),
-      getFileHashInfo(remoteFilePath),
-    ]);
-
-    const status = getFileSyncStatus(
-      localInfo.hash ?? null,
-      remoteInfo.hash ?? null
-    );
-
-    if (status === "unchanged") {
-      unchanged.push(file);
-      summary.unchanged++;
-    } else {
-      changes.push({
-        file,
-        status,
-        localHash: localInfo.hash ?? null,
-        remoteHash: remoteInfo.hash ?? null,
-      });
-
-      // Update summary
-      switch (status) {
-        case "local-only":
-          summary.localOnly++;
-          break;
-        case "remote-only":
-          summary.remoteOnly++;
-          break;
-        case "local-modified":
-          summary.localModified++;
-          break;
-      }
-    }
-  }
-
-  return { changes, unchanged, summary };
-}
-
-// Keep detectConflicts as an alias for backwards compatibility
-export const detectConflicts = detectChanges;

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

@@ -1,407 +0,0 @@
-/**
- * Sync daemon - watches directories and syncs automatically
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-
-import { createFileWatcher, type WatcherInstance, type FileChange } from "./watcher.js";
-import { push, pull } from "./operations.js";
-import { readRegistry, type Registry } from "./registry.js";
-import { getCentralRepoPath } from "./central.js";
-import { loadXdgConfig, getSyncConfig } from "../config.js";
-import { validateRegistry, type ValidationResult } from "./validation.js";
-
-const DAEMON_LOG_FILE = "daemon.log";
-const PID_FILE = "daemon.pid";
-const MAX_LOG_SIZE = 1024 * 1024; // 1MB
-
-export type DaemonOptions = {
-  /** Run in background (detach from terminal) */
-  background?: boolean;
-  /** Sync interval in milliseconds (for central repo polling) */
-  pollInterval?: number;
-  /** Validation interval in milliseconds (default: 5 minutes) */
-  validationInterval?: number;
-  /** Log level */
-  logLevel?: "debug" | "info" | "warn" | "error";
-};
-
-export type DaemonStatus = {
-  running: boolean;
-  pid?: number;
-  startTime?: string;
-  watchedDirs?: string[];
-};
-
-/**
- * Get the daemon directory path
- */
-export function getDaemonDir(): string {
-  return path.join(os.homedir(), ".minimem");
-}
-
-/**
- * Get PID file path
- */
-export function getPidFilePath(): string {
-  return path.join(getDaemonDir(), PID_FILE);
-}
-
-/**
- * Get daemon log path
- */
-export function getDaemonLogPath(): string {
-  return path.join(getDaemonDir(), DAEMON_LOG_FILE);
-}
-
-/**
- * Check if daemon is running
- */
-export async function isDaemonRunning(): Promise<boolean> {
-  const pidFile = getPidFilePath();
-
-  try {
-    const content = await fs.readFile(pidFile, "utf-8");
-    const pid = parseInt(content.trim(), 10);
-
-    if (isNaN(pid)) {
-      return false;
-    }
-
-    // Check if process is running
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch {
-      // Process not running, clean up stale PID file
-      await fs.unlink(pidFile).catch(() => {});
-      return false;
-    }
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get daemon status
- */
-export async function getDaemonStatus(): Promise<DaemonStatus> {
-  const running = await isDaemonRunning();
-
-  if (!running) {
-    return { running: false };
-  }
-
-  const pidFile = getPidFilePath();
-  const content = await fs.readFile(pidFile, "utf-8");
-  const pid = parseInt(content.trim(), 10);
-
-  return {
-    running: true,
-    pid,
-  };
-}
-
-/**
- * Write to daemon log
- */
-async function writeLog(
-  message: string,
-  level: "debug" | "info" | "warn" | "error" = "info"
-): Promise<void> {
-  const logPath = getDaemonLogPath();
-  const timestamp = new Date().toISOString();
-  const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-
-  try {
-    await fs.mkdir(path.dirname(logPath), { recursive: true });
-
-    // Rotate log if too large
-    try {
-      const stats = await fs.stat(logPath);
-      if (stats.size > MAX_LOG_SIZE) {
-        await fs.rename(logPath, `${logPath}.old`);
-      }
-    } catch {
-      // File doesn't exist
-    }
-
-    await fs.appendFile(logPath, line);
-  } catch (error) {
-    console.error(`Failed to write log: ${error}`);
-  }
-}
-
-/**
- * Stop the daemon
- */
-export async function stopDaemon(): Promise<boolean> {
-  const status = await getDaemonStatus();
-
-  if (!status.running || !status.pid) {
-    return false;
-  }
-
-  try {
-    process.kill(status.pid, "SIGTERM");
-
-    // Wait for process to exit
-    let attempts = 0;
-    while (attempts < 10) {
-      await new Promise((r) => setTimeout(r, 500));
-      if (!(await isDaemonRunning())) {
-        return true;
-      }
-      attempts++;
-    }
-
-    // Force kill if still running
-    try {
-      process.kill(status.pid, "SIGKILL");
-    } catch {
-      // Process may have already exited
-    }
-
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Start the daemon
- */
-export async function startDaemon(options: DaemonOptions = {}): Promise<void> {
-  const pollInterval = options.pollInterval ?? 30000; // 30 seconds
-
-  // Check if already running
-  if (await isDaemonRunning()) {
-    throw new Error("Daemon is already running");
-  }
-
-  // Write PID file
-  const daemonDir = getDaemonDir();
-  await fs.mkdir(daemonDir, { recursive: true });
-  await fs.writeFile(getPidFilePath(), String(process.pid));
-
-  await writeLog("Daemon starting");
-
-  // Get central repo path
-  const centralRepo = await getCentralRepoPath();
-  if (!centralRepo) {
-    await writeLog("No central repository configured", "warn");
-  }
-
-  // Get all directories with sync enabled from registry
-  const watchedDirs: Map<string, WatcherInstance> = new Map();
-  let running = true;
-
-  // Load directories from registry
-  async function loadWatchedDirs(): Promise<void> {
-    if (!centralRepo) return;
-
-    try {
-      const registry = await readRegistry(centralRepo);
-
-      // Get local directories that should be watched
-      const xdgConfig = await loadXdgConfig();
-      const machineId = xdgConfig.machineId;
-
-      for (const mapping of registry.mappings) {
-        if (mapping.machineId !== machineId) continue;
-
-        const localPath = mapping.localPath;
-
-        // Skip if already watching
-        if (watchedDirs.has(localPath)) continue;
-
-        // Check if sync is enabled for this directory
-        try {
-          const syncConfig = await getSyncConfig(localPath);
-          if (!syncConfig.enabled) continue;
-
-          // Start watcher
-          const watcher = createFileWatcher(localPath, {
-            debounceMs: 2000,
-          });
-
-          watcher.on("changes", async (changes: FileChange[]) => {
-            await handleLocalChanges(localPath, changes);
-          });
-
-          watchedDirs.set(localPath, watcher);
-          await writeLog(`Watching directory: ${localPath}`);
-        } catch (error) {
-          await writeLog(`Failed to watch ${localPath}: ${error}`, "error");
-        }
-      }
-    } catch (error) {
-      await writeLog(`Failed to load registry: ${error}`, "error");
-    }
-  }
-
-  // Handle local file changes
-  async function handleLocalChanges(
-    memoryDir: string,
-    changes: FileChange[]
-  ): Promise<void> {
-    await writeLog(`Local changes in ${memoryDir}: ${changes.map((c) => c.file).join(", ")}`);
-
-    try {
-      const syncConfig = await getSyncConfig(memoryDir);
-
-      if (syncConfig.autoSync) {
-        await writeLog(`Auto-pushing changes from ${memoryDir}`);
-        const result = await push(memoryDir, { dryRun: false });
-
-        if (result.success) {
-          await writeLog(`Pushed ${result.pushed.length} files from ${memoryDir}`);
-        } else {
-          await writeLog(
-            `Push failed for ${memoryDir}: ${result.errors.join(", ")}`,
-            "error"
-          );
-        }
-      }
-    } catch (error) {
-      await writeLog(`Failed to handle changes in ${memoryDir}: ${error}`, "error");
-    }
-  }
-
-  // Poll central repo for changes
-  async function pollCentralRepo(): Promise<void> {
-    if (!centralRepo) return;
-
-    try {
-      // Check for changes in central repo that need to be pulled
-      for (const [localPath] of watchedDirs) {
-        try {
-          const syncConfig = await getSyncConfig(localPath);
-
-          if (syncConfig.autoSync) {
-            const result = await pull(localPath, { dryRun: true });
-
-            if (result.pulled.length > 0) {
-              await writeLog(`Remote changes detected for ${localPath}, pulling...`);
-              await pull(localPath, { dryRun: false });
-            }
-          }
-        } catch (error) {
-          await writeLog(`Failed to check/pull for ${localPath}: ${error}`, "error");
-        }
-      }
-    } catch (error) {
-      await writeLog(`Failed to poll central repo: ${error}`, "error");
-    }
-  }
-
-  // Cleanup function
-  async function cleanup(): Promise<void> {
-    running = false;
-    await writeLog("Daemon stopping");
-
-    // Close all watchers
-    for (const [dir, watcher] of watchedDirs) {
-      try {
-        await watcher.close();
-        await writeLog(`Stopped watching: ${dir}`);
-      } catch (error) {
-        await writeLog(`Error closing watcher for ${dir}: ${error}`, "error");
-      }
-    }
-    watchedDirs.clear();
-
-    // Remove PID file
-    try {
-      await fs.unlink(getPidFilePath());
-    } catch {
-      // Ignore
-    }
-
-    await writeLog("Daemon stopped");
-  }
-
-  // Handle signals
-  process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
-  process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
-  // Validate registry on startup
-  async function runValidation(): Promise<void> {
-    try {
-      const result = await validateRegistry();
-
-      if (result.issues.length > 0) {
-        for (const issue of result.issues) {
-          const level = issue.severity === "error" ? "error" : "warn";
-          await writeLog(`Validation: ${issue.message}`, level);
-        }
-      }
-    } catch (error) {
-      await writeLog(`Validation failed: ${error}`, "error");
-    }
-  }
-
-  // Initial load and validation
-  await runValidation();
-  await loadWatchedDirs();
-
-  // Validation interval tracking
-  const validationInterval = options.validationInterval ?? 5 * 60 * 1000; // 5 minutes
-  let lastValidation = Date.now();
-
-  // Main loop
-  while (running) {
-    await new Promise((r) => setTimeout(r, pollInterval));
-
-    if (!running) break;
-
-    // Reload directories in case new ones were added
-    await loadWatchedDirs();
-
-    // Poll central repo for changes
-    await pollCentralRepo();
-
-    // Periodic validation
-    if (Date.now() - lastValidation > validationInterval) {
-      await runValidation();
-      lastValidation = Date.now();
-    }
-  }
-}
-
-/**
- * Run daemon in background (fork process)
- */
-export async function startDaemonBackground(): Promise<number> {
-  const { spawn } = await import("node:child_process");
-
-  // Get the path to the CLI
-  const cliPath = process.argv[1];
-
-  const child = spawn(process.execPath, [cliPath, "daemon", "--foreground"], {
-    detached: true,
-    stdio: "ignore",
-  });
-
-  child.unref();
-
-  if (child.pid) {
-    // Wait a moment and verify it started
-    await new Promise((r) => setTimeout(r, 1000));
-
-    if (await isDaemonRunning()) {
-      return child.pid;
-    }
-  }
-
-  throw new Error("Failed to start daemon in background");
-}