cognitive-core 0.2.0 → 0.2.2

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

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

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

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