claude-code-swarm 0.3.4 → 0.3.6

package/references/minimem/src/cli/commands/config.ts

@@ -0,0 +1,262 @@
+/**
+ * minimem config - View and manage configuration
+ */
+
+import {
+  resolveMemoryDir,
+  exitWithError,
+  loadConfig,
+  loadGlobalConfig,
+  loadXdgConfig,
+  saveConfig,
+  saveXdgConfig,
+  getConfigPath,
+  getGlobalConfigPath,
+  getXdgConfigPath,
+  mergeConfig,
+  getDefaultConfig,
+  getSyncConfig,
+  isInitialized,
+  formatPath,
+  type CliConfig,
+  type GlobalConfig,
+} from "../config.js";
+
+export type ConfigOptions = {
+  dir?: string;
+  global?: boolean;
+  xdgGlobal?: boolean;
+  json?: boolean;
+  set?: string;
+  unset?: string;
+};
+
+export async function config(options: ConfigOptions): Promise<void> {
+  // Handle --set and --unset
+  if (options.set || options.unset) {
+    await handleConfigEdit(options);
+    return;
+  }
+
+  // Show config
+  await showConfig(options);
+}
+
+async function showConfig(options: ConfigOptions): Promise<void> {
+  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  // Load configs
+  const globalConfig = await loadGlobalConfig();
+  const xdgConfig = await loadXdgConfig();
+  const localConfig = await loadConfig(memoryDir);
+  const mergedConfig = mergeConfig(localConfig);
+  const syncConfig = await getSyncConfig(memoryDir);
+  const defaults = getDefaultConfig();
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      effective: mergedConfig,
+      local: localConfig,
+      global: globalConfig,
+      xdgGlobal: xdgConfig,
+      syncConfig,
+      defaults,
+    }, null, 2));
+    return;
+  }
+
+  console.log("Minimem Configuration");
+  console.log("=====================");
+  console.log();
+
+  console.log("Config Files:");
+  console.log(`  XDG Global:    ${formatPath(getXdgConfigPath())}`);
+  console.log(`  Legacy Global: ${formatPath(getGlobalConfigPath())}`);
+  console.log(`  Local:         ${formatPath(getConfigPath(memoryDir))}`);
+  console.log();
+
+  console.log("Effective Configuration:");
+  console.log("(merged from defaults → xdg global → legacy global → local)");
+  console.log();
+
+  printConfigSection("Embedding", {
+    "provider": mergedConfig.embedding?.provider,
+    "model": mergedConfig.embedding?.model || "(provider default)",
+    "fallback": mergedConfig.embedding?.fallback || "none",
+  });
+
+  printConfigSection("Hybrid Search", {
+    "enabled": mergedConfig.hybrid?.enabled,
+    "vectorWeight": mergedConfig.hybrid?.vectorWeight,
+    "textWeight": mergedConfig.hybrid?.textWeight,
+  });
+
+  printConfigSection("Query Defaults", {
+    "maxResults": mergedConfig.query?.maxResults,
+    "minScore": mergedConfig.query?.minScore,
+  });
+
+  printConfigSection("Chunking", {
+    "tokens": mergedConfig.chunking?.tokens,
+    "overlap": mergedConfig.chunking?.overlap,
+  });
+
+  printConfigSection("Sync (Local)", {
+    "enabled": syncConfig.enabled,
+    "path": syncConfig.path || "(not configured)",
+    "include": syncConfig.include.join(", "),
+    "exclude": syncConfig.exclude.length > 0 ? syncConfig.exclude.join(", ") : "(none)",
+  });
+
+  printConfigSection("Sync (Global)", {
+    "centralRepo": syncConfig.centralRepo || "(not configured)",
+    "conflictStrategy": syncConfig.conflictStrategy,
+    "autoSync": syncConfig.autoSync,
+    "autoCommit": syncConfig.autoCommit,
+    "mergeResolver": syncConfig.mergeResolver || "(default)",
+  });
+
+  console.log();
+  console.log("To modify configuration:");
+  console.log("  minimem config --set embedding.provider=openai");
+  console.log("  minimem config --set sync.enabled=true");
+  console.log("  minimem config --set sync.path=myproject/");
+  console.log();
+  console.log("Global sync settings (use --xdg-global flag):");
+  console.log("  minimem config --xdg-global --set centralRepo=~/memories-repo");
+  console.log("  minimem config --xdg-global --set sync.conflictStrategy=merge");
+}
+
+function printConfigSection(title: string, values: Record<string, unknown>): void {
+  console.log(`  ${title}:`);
+  for (const [key, value] of Object.entries(values)) {
+    const displayValue = value === undefined ? "(default)" : String(value);
+    console.log(`    ${key}: ${displayValue}`);
+  }
+}
+
+async function handleConfigEdit(options: ConfigOptions): Promise<void> {
+  // Handle XDG global config edits
+  if (options.xdgGlobal) {
+    await handleXdgConfigEdit(options);
+    return;
+  }
+
+  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
+  const configPath = getConfigPath(memoryDir);
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  // Load current config (just the local file, not merged)
+  const currentConfig = await loadConfigFile(configPath);
+
+  if (options.set) {
+    const [keyPath, value] = options.set.split("=");
+    if (!keyPath || value === undefined) {
+      exitWithError(
+        "--set requires format: key.path=value",
+        "Example: --set embedding.provider=openai"
+      );
+    }
+
+    const newConfig = setConfigValue(currentConfig, keyPath, parseValue(value));
+    await saveConfig(memoryDir, newConfig);
+    console.log(`Set ${keyPath}=${value} in ${formatPath(configPath)}`);
+  }
+
+  if (options.unset) {
+    const keyPath = options.unset;
+    const newConfig = unsetConfigValue(currentConfig, keyPath);
+    await saveConfig(memoryDir, newConfig);
+    console.log(`Unset ${keyPath} in ${formatPath(configPath)}`);
+  }
+}
+
+async function handleXdgConfigEdit(options: ConfigOptions): Promise<void> {
+  const configPath = getXdgConfigPath();
+  const currentConfig = await loadXdgConfig();
+
+  if (options.set) {
+    const [keyPath, value] = options.set.split("=");
+    if (!keyPath || value === undefined) {
+      exitWithError(
+        "--set requires format: key.path=value",
+        "Example: --set centralRepo=~/memories-repo"
+      );
+    }
+
+    const newConfig = setConfigValue(currentConfig as Record<string, unknown>, keyPath, parseValue(value)) as GlobalConfig;
+    await saveXdgConfig(newConfig);
+    console.log(`Set ${keyPath}=${value} in ${formatPath(configPath)}`);
+  }
+
+  if (options.unset) {
+    const keyPath = options.unset;
+    const newConfig = unsetConfigValue(currentConfig as Record<string, unknown>, keyPath) as GlobalConfig;
+    await saveXdgConfig(newConfig);
+    console.log(`Unset ${keyPath} in ${formatPath(configPath)}`);
+  }
+}
+
+async function loadConfigFile(configPath: string): Promise<CliConfig> {
+  const fs = await import("node:fs/promises");
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(content) as CliConfig;
+  } catch {
+    return {};
+  }
+}
+
+function parseValue(value: string): unknown {
+  // Try to parse as JSON (for booleans, numbers, etc.)
+  try {
+    return JSON.parse(value);
+  } catch {
+    // Return as string
+    return value;
+  }
+}
+
+function setConfigValue<T extends Record<string, unknown>>(config: T, keyPath: string, value: unknown): T {
+  const parts = keyPath.split(".");
+  const result = { ...config } as Record<string, unknown>;
+  let current: Record<string, unknown> = result;
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    } else {
+      current[key] = { ...(current[key] as Record<string, unknown>) };
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+
+  current[parts[parts.length - 1]] = value;
+  return result as T;
+}
+
+function unsetConfigValue<T extends Record<string, unknown>>(config: T, keyPath: string): T {
+  const parts = keyPath.split(".");
+  const result = { ...config } as Record<string, unknown>;
+  let current: Record<string, unknown> = result;
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      return result as T; // Path doesn't exist
+    }
+    current[key] = { ...(current[key] as Record<string, unknown>) };
+    current = current[key] as Record<string, unknown>;
+  }
+
+  delete current[parts[parts.length - 1]];
+  return result as T;
+}

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

@@ -0,0 +1,415 @@
+/**
+ * minimem sync:conflicts - Conflict management commands
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+import {
+  resolveMemoryDir,
+  resolveConfigSubdir,
+  isInitialized,
+  formatPath,
+  getSyncConfig,
+  exitWithError,
+  warn,
+} from "../config.js";
+import {
+  listQuarantinedConflicts,
+  getConflictsDir,
+  getShadowsDir,
+} from "../sync/conflicts.js";
+import { getSyncStatePath, loadSyncState } from "../sync/state.js";
+
+export type ConflictsOptions = {
+  dir?: string;
+  global?: boolean;
+  json?: boolean;
+};
+
+/**
+ * List all quarantined conflicts
+ */
+export async function conflictsCommand(options: ConflictsOptions): Promise<void> {
+  const memoryDir = resolveMemoryDir({
+    dir: options.dir,
+    global: options.global,
+  });
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  try {
+    const conflicts = await listQuarantinedConflicts(memoryDir);
+
+    if (options.json) {
+      console.log(JSON.stringify(conflicts, null, 2));
+      return;
+    }
+
+    if (conflicts.length === 0) {
+      console.log("No quarantined conflicts.");
+      return;
+    }
+
+    console.log(`Quarantined conflicts in ${formatPath(memoryDir)}`);
+    console.log("-".repeat(50));
+
+    for (const conflict of conflicts) {
+      console.log(`\n${conflict.timestamp}:`);
+      for (const file of conflict.files) {
+        console.log(`  - ${file}`);
+      }
+    }
+
+    console.log(`\nTotal: ${conflicts.length} conflict set(s)`);
+    console.log("\nUse 'minimem sync:resolve <timestamp>' to resolve a conflict.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
+  }
+}
+
+export type ResolveOptions = {
+  dir?: string;
+  global?: boolean;
+  tool?: string;
+};
+
+/**
+ * Resolve a quarantined conflict
+ */
+export async function resolveCommand(
+  timestamp: string,
+  options: ResolveOptions
+): Promise<void> {
+  const memoryDir = resolveMemoryDir({
+    dir: options.dir,
+    global: options.global,
+  });
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  const conflictDir = path.join(getConflictsDir(memoryDir), timestamp);
+
+  try {
+    await fs.access(conflictDir);
+  } catch {
+    exitWithError(
+      `Conflict '${timestamp}' not found.`,
+      "Use 'minimem sync:conflicts' to list available conflicts."
+    );
+  }
+
+  try {
+    const files = await fs.readdir(conflictDir);
+
+    // Group files by base name
+    const fileGroups = new Map<string, { local?: string; remote?: string; base?: string }>();
+    for (const file of files) {
+      const match = file.match(/^(.+)\.(local|remote|base)$/);
+      if (match) {
+        const [, baseName, type] = match;
+        if (!fileGroups.has(baseName)) {
+          fileGroups.set(baseName, {});
+        }
+        const group = fileGroups.get(baseName)!;
+        group[type as "local" | "remote" | "base"] = path.join(conflictDir, file);
+      }
+    }
+
+    if (fileGroups.size === 0) {
+      exitWithError("No conflict files found in this directory.");
+    }
+
+    // Determine merge tool
+    const mergeTool = options.tool || process.env.MERGE_TOOL || await detectMergeTool();
+
+    if (!mergeTool) {
+      console.log("No merge tool detected. Available conflict files:");
+      for (const [baseName, group] of fileGroups) {
+        console.log(`\n${baseName.replace(/_/g, "/")}:`);
+        if (group.local) console.log(`  Local:  ${group.local}`);
+        if (group.remote) console.log(`  Remote: ${group.remote}`);
+        if (group.base) console.log(`  Base:   ${group.base}`);
+      }
+      console.log("\nManually edit the files or set MERGE_TOOL environment variable.");
+      return;
+    }
+
+    console.log(`Using merge tool: ${mergeTool}`);
+
+    for (const [baseName, group] of fileGroups) {
+      const fileName = baseName.replace(/_/g, "/");
+      console.log(`\nResolving: ${fileName}`);
+
+      if (group.local && group.remote) {
+        // Launch merge tool
+        const args = group.base
+          ? [group.local, group.base, group.remote]
+          : [group.local, group.remote];
+
+        const child = spawn(mergeTool, args, { stdio: "inherit" });
+
+        await new Promise<void>((resolve, reject) => {
+          child.on("close", (code) => {
+            if (code === 0) {
+              resolve();
+            } else {
+              reject(new Error(`Merge tool exited with code ${code}`));
+            }
+          });
+          child.on("error", reject);
+        });
+      }
+    }
+
+    console.log("\nMerge complete. Remove conflict directory when satisfied:");
+    console.log(`  rm -rf "${conflictDir}"`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
+  }
+}
+
+/**
+ * Detect available merge tool
+ */
+async function detectMergeTool(): Promise<string | null> {
+  const tools = ["code", "meld", "kdiff3", "vimdiff", "opendiff"];
+
+  for (const tool of tools) {
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync(`which ${tool}`, { stdio: "ignore" });
+      return tool;
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+export type CleanupOptions = {
+  dir?: string;
+  global?: boolean;
+  days?: number;
+  dryRun?: boolean;
+};
+
+/**
+ * Clean up old quarantined conflicts
+ */
+export async function cleanupCommand(options: CleanupOptions): Promise<void> {
+  const memoryDir = resolveMemoryDir({
+    dir: options.dir,
+    global: options.global,
+  });
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  const maxAgeDays = options.days ?? 30;
+  const cutoffDate = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1000);
+
+  try {
+    const conflictsDir = getConflictsDir(memoryDir);
+    let entries: string[] = [];
+
+    try {
+      entries = await fs.readdir(conflictsDir);
+    } catch {
+      console.log("No conflicts directory found.");
+      return;
+    }
+
+    let cleaned = 0;
+    let kept = 0;
+
+    for (const entry of entries) {
+      // Timestamps are in ISO format with : and . replaced with -
+      // e.g., 2026-02-03T07-20-56-704Z
+      const timestamp = entry.replace(/-(\d{2})-(\d{2})-(\d{3})Z$/, ":$1:$2.$3Z");
+      const entryDate = new Date(timestamp);
+
+      if (isNaN(entryDate.getTime())) {
+        console.log(`  Skipping invalid timestamp: ${entry}`);
+        continue;
+      }
+
+      const entryPath = path.join(conflictsDir, entry);
+
+      if (entryDate < cutoffDate) {
+        if (options.dryRun) {
+          console.log(`  Would remove: ${entry}`);
+        } else {
+          await fs.rm(entryPath, { recursive: true, force: true });
+          console.log(`  Removed: ${entry}`);
+        }
+        cleaned++;
+      } else {
+        kept++;
+      }
+    }
+
+    if (options.dryRun) {
+      console.log(`\nWould remove ${cleaned} conflict(s), keep ${kept}`);
+    } else {
+      console.log(`\nRemoved ${cleaned} conflict(s), kept ${kept}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
+  }
+}
+
+/**
+ * Sync logging
+ */
+const SYNC_LOG_FILE = "sync.log";
+const MAX_LOG_ENTRIES = 1000;
+
+export type SyncLogEntry = {
+  timestamp: string;
+  operation: "push" | "pull" | "sync";
+  result: "success" | "partial" | "failure";
+  pushed?: number;
+  pulled?: number;
+  conflicts?: number;
+  errors?: string[];
+};
+
+/**
+ * Get sync log path
+ */
+export function getSyncLogPath(memoryDir: string): string {
+  const subdir = resolveConfigSubdir(memoryDir);
+  return path.join(memoryDir, subdir, SYNC_LOG_FILE);
+}
+
+/**
+ * Append to sync log
+ */
+export async function appendSyncLog(
+  memoryDir: string,
+  entry: SyncLogEntry
+): Promise<void> {
+  const logPath = getSyncLogPath(memoryDir);
+
+  try {
+    await fs.mkdir(path.dirname(logPath), { recursive: true });
+
+    // Read existing log
+    let entries: SyncLogEntry[] = [];
+    try {
+      const content = await fs.readFile(logPath, "utf-8");
+      entries = content
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+    } catch {
+      // No existing log
+    }
+
+    // Add new entry and trim if needed
+    entries.push(entry);
+    if (entries.length > MAX_LOG_ENTRIES) {
+      entries = entries.slice(-MAX_LOG_ENTRIES);
+    }
+
+    // Write back
+    const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await fs.writeFile(logPath, content);
+  } catch (error) {
+    // Log failures are non-fatal
+    const message = error instanceof Error ? error.message : String(error);
+    warn(`Failed to write sync log: ${message}`);
+  }
+}
+
+/**
+ * Read sync log
+ */
+export async function readSyncLog(memoryDir: string): Promise<SyncLogEntry[]> {
+  const logPath = getSyncLogPath(memoryDir);
+
+  try {
+    const content = await fs.readFile(logPath, "utf-8");
+    return content
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+export type LogOptions = {
+  dir?: string;
+  global?: boolean;
+  limit?: number;
+  json?: boolean;
+};
+
+/**
+ * Show sync log
+ */
+export async function logCommand(options: LogOptions): Promise<void> {
+  const memoryDir = resolveMemoryDir({
+    dir: options.dir,
+    global: options.global,
+  });
+
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(`${formatPath(memoryDir)} is not initialized.`);
+  }
+
+  try {
+    let entries = await readSyncLog(memoryDir);
+
+    const limit = options.limit ?? 20;
+    entries = entries.slice(-limit);
+
+    if (options.json) {
+      console.log(JSON.stringify(entries, null, 2));
+      return;
+    }
+
+    if (entries.length === 0) {
+      console.log("No sync history.");
+      return;
+    }
+
+    console.log(`Sync history for ${formatPath(memoryDir)}`);
+    console.log("-".repeat(60));
+
+    for (const entry of entries) {
+      const time = new Date(entry.timestamp).toLocaleString();
+      const status =
+        entry.result === "success" ? "OK" :
+        entry.result === "partial" ? "PARTIAL" : "FAILED";
+
+      let details = "";
+      if (entry.pushed) details += ` +${entry.pushed}`;
+      if (entry.pulled) details += ` -${entry.pulled}`;
+      if (entry.conflicts) details += ` !${entry.conflicts}`;
+
+      console.log(`${time}  ${entry.operation.padEnd(6)}  ${status.padEnd(8)}${details}`);
+
+      if (entry.errors && entry.errors.length > 0) {
+        for (const error of entry.errors.slice(0, 3)) {
+          console.log(`    Error: ${error}`);
+        }
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(message);
+  }
+}