cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,138 @@
+/**
+ * Directory type detection for sync system
+ *
+ * Detects whether a memory directory is:
+ * - project-bound: inside git repo (synced via project's git)
+ * - standalone: has minimem sync config (synced via central repo)
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getConfigPath } from "../config.js";
+
+/**
+ * Directory type for sync purposes
+ *
+ * - project-bound: Memory is inside a git repo and synced via project's git
+ * - standalone: Memory has minimem sync config and syncs via central repo
+ */
+export type DirectoryType = "project-bound" | "standalone";
+
+/**
+ * Check if a directory is inside a git repository
+ * Walks up the directory tree looking for .git
+ */
+export async function isInsideGitRepo(dir: string): Promise<boolean> {
+  let current = path.resolve(dir);
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    try {
+      const gitPath = path.join(current, ".git");
+      const stat = await fs.stat(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        // .git can be a file in worktrees
+        return true;
+      }
+    } catch {
+      // .git doesn't exist at this level, continue up
+    }
+    current = path.dirname(current);
+  }
+
+  return false;
+}
+
+/**
+ * Get the root of the git repository containing a directory
+ * Returns undefined if not inside a git repo
+ */
+export async function getGitRoot(dir: string): Promise<string | undefined> {
+  let current = path.resolve(dir);
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    try {
+      const gitPath = path.join(current, ".git");
+      const stat = await fs.stat(gitPath);
+      if (stat.isDirectory() || stat.isFile()) {
+        return current;
+      }
+    } catch {
+      // Continue up
+    }
+    current = path.dirname(current);
+  }
+
+  return undefined;
+}
+
+/**
+ * Check if a directory has sync configuration enabled
+ */
+export async function hasSyncConfig(dir: string): Promise<boolean> {
+  const configPath = getConfigPath(dir);
+
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config = JSON.parse(content);
+    // Check if sync is explicitly enabled or has a path configured
+    return config.sync?.enabled === true || typeof config.sync?.path === "string";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect the directory type based on git repo presence and sync config
+ *
+ * - If has sync config -> standalone (uses minimem central repo sync)
+ * - If inside git repo -> project-bound (synced via project's git)
+ * - Otherwise -> standalone (default, can set up sync later)
+ */
+export async function detectDirectoryType(dir: string): Promise<DirectoryType> {
+  const hasSync = await hasSyncConfig(dir);
+
+  // If has sync config, it's standalone (uses minimem sync)
+  if (hasSync) {
+    return "standalone";
+  }
+
+  // If inside git repo, it's project-bound (synced via git)
+  const inGit = await isInsideGitRepo(dir);
+  if (inGit) {
+    return "project-bound";
+  }
+
+  // Default to standalone (can set up sync later)
+  return "standalone";
+}
+
+/**
+ * Get detailed directory info including type and git root
+ */
+export async function getDirectoryInfo(dir: string): Promise<{
+  type: DirectoryType;
+  gitRoot?: string;
+  hasSyncConfig: boolean;
+}> {
+  const [hasSync, gitRoot] = await Promise.all([
+    hasSyncConfig(dir),
+    getGitRoot(dir),
+  ]);
+
+  let type: DirectoryType;
+  if (hasSync) {
+    type = "standalone";
+  } else if (gitRoot !== undefined) {
+    type = "project-bound";
+  } else {
+    type = "standalone";
+  }
+
+  return {
+    type,
+    gitRoot,
+    hasSyncConfig: hasSync,
+  };
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Sync module - Git-based syncing for memory directories
+ */
+
+export {
+  type DirectoryType,
+  detectDirectoryType,
+  isInsideGitRepo,
+  getGitRoot,
+  hasSyncConfig,
+  getDirectoryInfo,
+} from "./detection.js";
+
+export {
+  type Registry,
+  type RegistryMapping,
+  type CollisionCheckResult,
+  createEmptyRegistry,
+  readRegistry,
+  writeRegistry,
+  getRegistryPath,
+  checkCollision,
+  addMapping,
+  removeMapping,
+  findMapping,
+  getMachineMappings,
+  updateLastSync,
+  normalizePath,
+  compressPath,
+  normalizeRepoPath,
+} from "./registry.js";
+
+export {
+  type InitCentralResult,
+  initCentralRepo,
+  validateCentralRepo,
+  getCentralRepoPath,
+} from "./central.js";
+
+export {
+  type SyncState,
+  type FileHashInfo,
+  type FileSyncStatus,
+  createEmptySyncState,
+  loadSyncState,
+  saveSyncState,
+  computeFileHash,
+  computeContentHash,
+  listSyncableFiles,
+  getFileHashInfo,
+  getFileSyncStatus,
+  updateSyncStateAfterSync,
+  removeFileFromSyncState,
+  buildSyncState,
+  getSyncStatePath,
+} from "./state.js";
+
+export {
+  type FileConflict,
+  type ConflictDetectionResult,
+  detectConflicts,
+  createShadowCopy,
+  readShadowCopy,
+  deleteShadowCopy,
+  cleanShadows,
+  quarantineConflict,
+  listQuarantinedConflicts,
+  getShadowsDir,
+  getConflictsDir,
+  createShadowsForConflicts,
+} from "./conflicts.js";
+
+export {
+  type SyncResult,
+  push,
+  pull,
+  bidirectionalSync,
+} from "./operations.js";
+
+export {
+  type WatcherEvent,
+  type FileChange,
+  type WatcherOptions,
+  type WatcherInstance,
+  createFileWatcher,
+  createMultiDirWatcher,
+} from "./watcher.js";
+
+export {
+  type DaemonOptions,
+  type DaemonStatus,
+  getDaemonDir,
+  getPidFilePath,
+  getDaemonLogPath,
+  isDaemonRunning,
+  getDaemonStatus,
+  stopDaemon,
+  startDaemon,
+  startDaemonBackground,
+} from "./daemon.js";
+
+export {
+  type ValidationIssue,
+  type ValidationResult,
+  validateRegistry,
+  formatValidationResult,
+} from "./validation.js";

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

@@ -0,0 +1,373 @@
+/**
+ * Sync operations - push and pull
+ *
+ * Uses last-write-wins conflict resolution:
+ * - Push: local overwrites remote
+ * - Pull: remote overwrites local
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+import { getSyncConfig } from "../config.js";
+import { getCentralRepoPath } from "./central.js";
+import {
+  loadSyncState,
+  saveSyncState,
+  listSyncableFiles,
+  computeFileHash,
+  getFileSyncStatus,
+  getFileHashInfo,
+} from "./state.js";
+import { readRegistry, writeRegistry, updateLastSync } from "./registry.js";
+import { getMachineId } from "../config.js";
+import { appendSyncLog, type SyncLogEntry } from "../commands/conflicts.js";
+
+export type SyncResult = {
+  success: boolean;
+  pushed: string[];
+  pulled: string[];
+  errors: string[];
+  skipped: string[];
+};
+
+/**
+ * Ensure a directory exists
+ */
+async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Copy a file atomically via temp file
+ */
+async function copyFileAtomic(src: string, dest: string): Promise<void> {
+  const destDir = path.dirname(dest);
+  await ensureDir(destDir);
+
+  const tempDest = `${dest}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+
+  try {
+    await fs.copyFile(src, tempDest);
+    await fs.rename(tempDest, dest);
+  } catch (error) {
+    // Clean up temp file on error
+    try {
+      await fs.unlink(tempDest);
+    } catch {
+      // Ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Push local changes to central repository
+ *
+ * Last-write-wins: local files always overwrite remote files
+ */
+export async function push(
+  memoryDir: string,
+  options: {
+    force?: boolean;
+    dryRun?: boolean;
+  } = {}
+): Promise<SyncResult> {
+  const result: SyncResult = {
+    success: true,
+    pushed: [],
+    pulled: [],
+    errors: [],
+    skipped: [],
+  };
+
+  // Get config
+  const syncConfig = await getSyncConfig(memoryDir);
+  if (!syncConfig.enabled || !syncConfig.path) {
+    result.success = false;
+    result.errors.push("Sync not configured for this directory");
+    return result;
+  }
+
+  const centralRepo = await getCentralRepoPath();
+  if (!centralRepo) {
+    result.success = false;
+    result.errors.push("No central repository configured");
+    return result;
+  }
+
+  const remotePath = path.join(centralRepo, syncConfig.path);
+
+  // Load state
+  const state = await loadSyncState(memoryDir, syncConfig.path);
+
+  // Get all local files
+  const localFiles = await listSyncableFiles(
+    memoryDir,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+
+  // Get all remote files for comparison
+  const remoteFiles = await listSyncableFiles(
+    remotePath,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+
+  const allFiles = new Set([...localFiles, ...remoteFiles]);
+
+  // Process each file
+  for (const file of allFiles) {
+    const localPath = path.join(memoryDir, file);
+    const remoteFilePath = path.join(remotePath, file);
+
+    try {
+      const [localInfo, remoteInfo] = await Promise.all([
+        getFileHashInfo(localPath),
+        getFileHashInfo(remoteFilePath),
+      ]);
+
+      const status = getFileSyncStatus(
+        localInfo.hash ?? null,
+        remoteInfo.hash ?? null
+      );
+
+      switch (status) {
+        case "unchanged":
+          // Already in sync
+          break;
+
+        case "local-only":
+        case "local-modified":
+          // Push local to remote (last-write-wins)
+          if (!options.dryRun) {
+            await copyFileAtomic(localPath, remoteFilePath);
+            const hash = localInfo.hash!;
+            state.files[file] = {
+              localHash: hash,
+              remoteHash: hash,
+              lastModified: new Date().toISOString(),
+            };
+          }
+          result.pushed.push(file);
+          break;
+
+        case "remote-only":
+          // File only exists on remote - skip on push (don't delete)
+          result.skipped.push(file);
+          break;
+
+        default:
+          result.skipped.push(file);
+          break;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(`${file}: ${message}`);
+      result.success = false;
+    }
+  }
+
+  // Save state and update registry
+  if (!options.dryRun && result.pushed.length > 0) {
+    state.lastSync = new Date().toISOString();
+    await saveSyncState(memoryDir, state);
+
+    // Update registry lastSync
+    const machineId = await getMachineId();
+    const registry = await readRegistry(centralRepo);
+    const updatedRegistry = updateLastSync(registry, syncConfig.path, machineId);
+    await writeRegistry(centralRepo, updatedRegistry);
+  }
+
+  // Log the sync operation
+  if (!options.dryRun) {
+    const logEntry: SyncLogEntry = {
+      timestamp: new Date().toISOString(),
+      operation: "push",
+      result: result.success ? "success" : "failure",
+      pushed: result.pushed.length,
+      errors: result.errors.length > 0 ? result.errors : undefined,
+    };
+    await appendSyncLog(memoryDir, logEntry);
+  }
+
+  return result;
+}
+
+/**
+ * Pull changes from central repository
+ *
+ * Last-write-wins: remote files always overwrite local files
+ */
+export async function pull(
+  memoryDir: string,
+  options: {
+    force?: boolean;
+    dryRun?: boolean;
+  } = {}
+): Promise<SyncResult> {
+  const result: SyncResult = {
+    success: true,
+    pushed: [],
+    pulled: [],
+    errors: [],
+    skipped: [],
+  };
+
+  // Get config
+  const syncConfig = await getSyncConfig(memoryDir);
+  if (!syncConfig.enabled || !syncConfig.path) {
+    result.success = false;
+    result.errors.push("Sync not configured for this directory");
+    return result;
+  }
+
+  const centralRepo = await getCentralRepoPath();
+  if (!centralRepo) {
+    result.success = false;
+    result.errors.push("No central repository configured");
+    return result;
+  }
+
+  const remotePath = path.join(centralRepo, syncConfig.path);
+
+  // Load state
+  const state = await loadSyncState(memoryDir, syncConfig.path);
+
+  // Get all files from both sides
+  const localFiles = await listSyncableFiles(
+    memoryDir,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+
+  const remoteFiles = await listSyncableFiles(
+    remotePath,
+    syncConfig.include,
+    syncConfig.exclude
+  );
+
+  const allFiles = new Set([...localFiles, ...remoteFiles]);
+
+  // Process each file
+  for (const file of allFiles) {
+    const localPath = path.join(memoryDir, file);
+    const remoteFilePath = path.join(remotePath, file);
+
+    try {
+      const [localInfo, remoteInfo] = await Promise.all([
+        getFileHashInfo(localPath),
+        getFileHashInfo(remoteFilePath),
+      ]);
+
+      const status = getFileSyncStatus(
+        localInfo.hash ?? null,
+        remoteInfo.hash ?? null
+      );
+
+      switch (status) {
+        case "unchanged":
+          // Already in sync
+          break;
+
+        case "remote-only":
+          // Pull new remote file to local
+          if (!options.dryRun) {
+            await copyFileAtomic(remoteFilePath, localPath);
+            const hash = remoteInfo.hash!;
+            state.files[file] = {
+              localHash: hash,
+              remoteHash: hash,
+              lastModified: new Date().toISOString(),
+            };
+          }
+          result.pulled.push(file);
+          break;
+
+        case "local-modified":
+          // Both have changes - with last-write-wins, pull overwrites local
+          if (options.force || !localInfo.exists) {
+            if (!options.dryRun) {
+              await copyFileAtomic(remoteFilePath, localPath);
+              const hash = remoteInfo.hash!;
+              state.files[file] = {
+                localHash: hash,
+                remoteHash: hash,
+                lastModified: new Date().toISOString(),
+              };
+            }
+            result.pulled.push(file);
+          } else {
+            // Without --force, skip files that have local changes
+            result.skipped.push(file);
+          }
+          break;
+
+        case "local-only":
+          // File only exists locally - skip on pull (don't delete)
+          result.skipped.push(file);
+          break;
+
+        default:
+          result.skipped.push(file);
+          break;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(`${file}: ${message}`);
+      result.success = false;
+    }
+  }
+
+  // Save state and update registry
+  if (!options.dryRun && result.pulled.length > 0) {
+    state.lastSync = new Date().toISOString();
+    await saveSyncState(memoryDir, state);
+
+    // Update registry lastSync
+    const machineId = await getMachineId();
+    const registry = await readRegistry(centralRepo);
+    const updatedRegistry = updateLastSync(registry, syncConfig.path, machineId);
+    await writeRegistry(centralRepo, updatedRegistry);
+  }
+
+  // Log the sync operation
+  if (!options.dryRun) {
+    const logEntry: SyncLogEntry = {
+      timestamp: new Date().toISOString(),
+      operation: "pull",
+      result: result.success ? "success" : "failure",
+      pulled: result.pulled.length,
+      errors: result.errors.length > 0 ? result.errors : undefined,
+    };
+    await appendSyncLog(memoryDir, logEntry);
+  }
+
+  return result;
+}
+
+/**
+ * Bidirectional sync - push local changes, pull remote changes
+ */
+export async function bidirectionalSync(
+  memoryDir: string,
+  options: {
+    force?: boolean;
+    dryRun?: boolean;
+  } = {}
+): Promise<SyncResult> {
+  // First push, then pull
+  const pushResult = await push(memoryDir, options);
+  const pullResult = await pull(memoryDir, options);
+
+  return {
+    success: pushResult.success && pullResult.success,
+    pushed: pushResult.pushed,
+    pulled: pullResult.pulled,
+    errors: [...pushResult.errors, ...pullResult.errors],
+    skipped: [...new Set([...pushResult.skipped, ...pullResult.skipped])],
+  };
+}