macro-agent 0.1.2 → 0.1.3

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

@@ -1,413 +0,0 @@
-/**
- * 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,
-  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 {
-  return path.join(memoryDir, ".minimem", 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);
-  }
-}

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

@@ -1,169 +0,0 @@
-/**
- * minimem daemon - Background sync daemon commands
- */
-
-import fs from "node:fs/promises";
-
-import {
-  startDaemon,
-  startDaemonBackground,
-  stopDaemon,
-  getDaemonStatus,
-  isDaemonRunning,
-  getDaemonLogPath,
-} from "../sync/daemon.js";
-import { exitWithError } from "../config.js";
-
-export type DaemonOptions = {
-  background?: boolean;
-  foreground?: boolean;
-};
-
-/**
- * Start the daemon
- */
-export async function daemonCommand(options: DaemonOptions): Promise<void> {
-  // If --foreground is specified, run in foreground (used by background spawn)
-  if (options.foreground) {
-    console.log("Starting daemon in foreground...");
-    try {
-      await startDaemon();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      exitWithError(`Daemon: ${message}`);
-    }
-    return;
-  }
-
-  // Check if already running
-  if (await isDaemonRunning()) {
-    console.log("Daemon is already running.");
-    console.log("Use 'minimem daemon:stop' to stop it.");
-    return;
-  }
-
-  if (options.background) {
-    console.log("Starting daemon in background...");
-    try {
-      const pid = await startDaemonBackground();
-      console.log(`Daemon started with PID ${pid}`);
-      console.log(`Log file: ${getDaemonLogPath()}`);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      exitWithError(`Failed to start daemon: ${message}`);
-    }
-  } else {
-    console.log("Starting daemon in foreground...");
-    console.log("Press Ctrl+C to stop.");
-    console.log("");
-    try {
-      await startDaemon();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      exitWithError(`Daemon: ${message}`);
-    }
-  }
-}
-
-/**
- * Stop the daemon
- */
-export async function daemonStopCommand(): Promise<void> {
-  const status = await getDaemonStatus();
-
-  if (!status.running) {
-    console.log("Daemon is not running.");
-    return;
-  }
-
-  console.log(`Stopping daemon (PID ${status.pid})...`);
-
-  const stopped = await stopDaemon();
-
-  if (stopped) {
-    console.log("Daemon stopped.");
-  } else {
-    exitWithError("Failed to stop daemon.");
-  }
-}
-
-/**
- * Show daemon status
- */
-export async function daemonStatusCommand(): Promise<void> {
-  const status = await getDaemonStatus();
-
-  if (status.running) {
-    console.log("Daemon status: running");
-    console.log(`  PID: ${status.pid}`);
-    console.log(`  Log: ${getDaemonLogPath()}`);
-  } else {
-    console.log("Daemon status: stopped");
-  }
-}
-
-export type LogOptions = {
-  lines?: number;
-  follow?: boolean;
-};
-
-/**
- * Show daemon logs
- */
-export async function daemonLogsCommand(options: LogOptions): Promise<void> {
-  const logPath = getDaemonLogPath();
-
-  try {
-    const content = await fs.readFile(logPath, "utf-8");
-    const lines = content.split("\n").filter(Boolean);
-
-    const numLines = options.lines ?? 50;
-    const displayLines = lines.slice(-numLines);
-
-    for (const line of displayLines) {
-      console.log(line);
-    }
-
-    if (options.follow) {
-      console.log("\n--- Following log (Ctrl+C to stop) ---\n");
-
-      // Simple follow implementation using polling
-      let lastSize = (await fs.stat(logPath)).size;
-
-      const poll = async () => {
-        try {
-          const stats = await fs.stat(logPath);
-          if (stats.size > lastSize) {
-            const fd = await fs.open(logPath, "r");
-            const buffer = Buffer.alloc(stats.size - lastSize);
-            await fd.read(buffer, 0, buffer.length, lastSize);
-            await fd.close();
-
-            process.stdout.write(buffer.toString());
-            lastSize = stats.size;
-          }
-        } catch {
-          // File may have been rotated
-          lastSize = 0;
-        }
-      };
-
-      const interval = setInterval(poll, 1000);
-
-      process.on("SIGINT", () => {
-        clearInterval(interval);
-        process.exit(0);
-      });
-
-      // Keep running
-      await new Promise(() => {});
-    }
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      console.log("No daemon log found.");
-    } else {
-      const message = error instanceof Error ? error.message : String(error);
-      exitWithError(`Error reading log: ${message}`);
-    }
-  }
-}

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

@@ -1,12 +0,0 @@
-/**
- * CLI Commands
- */
-
-export { init, type InitOptions } from "./init.js";
-export { search, type SearchOptions } from "./search.js";
-export { sync, type SyncOptions } from "./sync.js";
-export { status, type StatusOptions } from "./status.js";
-export { append, type AppendOptions } from "./append.js";
-export { upsert, type UpsertOptions } from "./upsert.js";
-export { mcp, type McpOptions } from "./mcp.js";
-export { config, type ConfigOptions } from "./config.js";

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

@@ -1,88 +0,0 @@
-/**
- * minimem init - Initialize memory directory
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import {
-  resolveMemoryDir,
-  saveConfig,
-  getInitConfig,
-  isInitialized,
-  formatPath,
-} from "../config.js";
-
-const MEMORY_TEMPLATE = `# Memory
-
-This is your memory file. Add notes, decisions, and context here.
-
-## Quick Start
-
-- Add daily logs in the \`memory/\` directory (e.g., \`memory/2024-01-15.md\`)
-- Use \`minimem search <query>\` to find relevant memories
-- Use \`minimem append <text>\` to quickly add to today's log
-
-## Notes
-
-`;
-
-export type InitOptions = {
-  global?: boolean;
-  force?: boolean;
-};
-
-export async function init(
-  dir: string | undefined,
-  options: InitOptions,
-): Promise<void> {
-  const memoryDir = resolveMemoryDir({ dir, global: options.global });
-  const displayPath = formatPath(memoryDir);
-
-  // Check if already initialized
-  if (!options.force && (await isInitialized(memoryDir))) {
-    console.log(`Already initialized: ${displayPath}`);
-    console.log("Use --force to reinitialize");
-    return;
-  }
-
-  console.log(`Initializing minimem in ${displayPath}...`);
-
-  // Create directories
-  await fs.mkdir(memoryDir, { recursive: true });
-  await fs.mkdir(path.join(memoryDir, "memory"), { recursive: true });
-  await fs.mkdir(path.join(memoryDir, ".minimem"), { recursive: true });
-
-  // Create MEMORY.md if it doesn't exist
-  const memoryFilePath = path.join(memoryDir, "MEMORY.md");
-  try {
-    await fs.access(memoryFilePath);
-    console.log("  MEMORY.md already exists, skipping");
-  } catch {
-    await fs.writeFile(memoryFilePath, MEMORY_TEMPLATE, "utf-8");
-    console.log("  Created MEMORY.md");
-  }
-
-  // Create config
-  const config = getInitConfig();
-  await saveConfig(memoryDir, config);
-  console.log("  Created .minimem/config.json");
-
-  // Create .gitignore for .minimem directory
-  const gitignorePath = path.join(memoryDir, ".minimem", ".gitignore");
-  await fs.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
-  console.log("  Created .minimem/.gitignore");
-
-  console.log();
-  console.log("Done! Your memory directory is ready.");
-  console.log();
-  console.log("Next steps:");
-  console.log(`  1. Set your embedding API key:`);
-  console.log(`     export OPENAI_API_KEY=your-key`);
-  console.log(`     # or: export GOOGLE_API_KEY=your-key`);
-  console.log();
-  console.log(`  2. Add some memories to MEMORY.md or memory/*.md`);
-  console.log();
-  console.log(`  3. Search your memories:`);
-  console.log(`     minimem search "your query"${dir ? ` --dir ${dir}` : ""}`);
-}