macro-agent 0.1.0 → 0.1.2

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

@@ -0,0 +1,141 @@
+/**
+ * Tests for conflict CLI commands and sync logging
+ */
+
+import { describe, it, beforeEach, afterEach, expect } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+import {
+  appendSyncLog,
+  readSyncLog,
+  getSyncLogPath,
+  type SyncLogEntry,
+} from "../conflicts.js";
+
+describe("sync logging", () => {
+  let tempDir: string;
+  let memoryDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-log-test-"));
+    memoryDir = path.join(tempDir, "memory");
+    await fs.mkdir(memoryDir, { recursive: true });
+    await fs.mkdir(path.join(memoryDir, ".minimem"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("appendSyncLog", () => {
+    it("should create log file if not exists", async () => {
+      const entry: SyncLogEntry = {
+        timestamp: new Date().toISOString(),
+        operation: "push",
+        result: "success",
+        pushed: 3,
+      };
+
+      await appendSyncLog(memoryDir, entry);
+
+      const logPath = getSyncLogPath(memoryDir);
+      const exists = await fs.access(logPath).then(() => true).catch(() => false);
+      expect(exists).toBeTruthy();
+    });
+
+    it("should append multiple entries", async () => {
+      const entry1: SyncLogEntry = {
+        timestamp: new Date().toISOString(),
+        operation: "push",
+        result: "success",
+        pushed: 2,
+      };
+
+      const entry2: SyncLogEntry = {
+        timestamp: new Date().toISOString(),
+        operation: "pull",
+        result: "success",
+        pulled: 3,
+      };
+
+      await appendSyncLog(memoryDir, entry1);
+      await appendSyncLog(memoryDir, entry2);
+
+      const entries = await readSyncLog(memoryDir);
+      expect(entries.length).toBe(2);
+      expect(entries[0].operation).toBe("push");
+      expect(entries[1].operation).toBe("pull");
+    });
+
+    it("should store error messages", async () => {
+      const entry: SyncLogEntry = {
+        timestamp: new Date().toISOString(),
+        operation: "push",
+        result: "failure",
+        errors: ["File not found", "Permission denied"],
+      };
+
+      await appendSyncLog(memoryDir, entry);
+
+      const entries = await readSyncLog(memoryDir);
+      expect(entries.length).toBe(1);
+      expect(entries[0].errors).toEqual(["File not found", "Permission denied"]);
+    });
+
+    it("should record conflict count", async () => {
+      const entry: SyncLogEntry = {
+        timestamp: new Date().toISOString(),
+        operation: "push",
+        result: "partial",
+        pushed: 2,
+        conflicts: 1,
+      };
+
+      await appendSyncLog(memoryDir, entry);
+
+      const entries = await readSyncLog(memoryDir);
+      expect(entries[0].conflicts).toBe(1);
+      expect(entries[0].result).toBe("partial");
+    });
+  });
+
+  describe("readSyncLog", () => {
+    it("should return empty array when no log exists", async () => {
+      const entries = await readSyncLog(memoryDir);
+      expect(entries).toEqual([]);
+    });
+
+    it("should parse JSONL format", async () => {
+      const logPath = getSyncLogPath(memoryDir);
+      const entries = [
+        { timestamp: "2024-01-01T10:00:00Z", operation: "push", result: "success", pushed: 1 },
+        { timestamp: "2024-01-01T11:00:00Z", operation: "pull", result: "success", pulled: 2 },
+      ];
+
+      await fs.mkdir(path.dirname(logPath), { recursive: true });
+      await fs.writeFile(
+        logPath,
+        entries.map((e) => JSON.stringify(e)).join("\n") + "\n"
+      );
+
+      const read = await readSyncLog(memoryDir);
+      expect(read.length).toBe(2);
+      expect(read[0].pushed).toBe(1);
+      expect(read[1].pulled).toBe(2);
+    });
+  });
+
+  describe("getSyncLogPath", () => {
+    it("should return path in .minimem directory", () => {
+      const logPath = getSyncLogPath(memoryDir);
+      expect(logPath.includes(".minimem")).toBeTruthy();
+      expect(logPath.endsWith("sync.log")).toBeTruthy();
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+/**
+ * minimem append - Quick append to today's daily log
+ */
+
+import { Minimem } from "../../minimem.js";
+import {
+  resolveMemoryDir,
+  exitWithError,
+  loadConfig,
+  buildMinimemConfig,
+  isInitialized,
+  formatPath,
+} from "../config.js";
+
+export type AppendOptions = {
+  dir?: string;
+  global?: boolean;
+  file?: string;
+  provider?: string;
+  session?: string;
+  sessionSource?: string;
+};
+
+export async function append(
+  text: string,
+  options: AppendOptions,
+): Promise<void> {
+  const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
+
+  // Check if initialized
+  if (!(await isInitialized(memoryDir))) {
+    exitWithError(
+      `${formatPath(memoryDir)} is not initialized.`,
+      `Run: minimem init${options.dir ? ` ${options.dir}` : ""}`
+    );
+  }
+
+  // Add session marker if explicit session provided
+  let finalText = text;
+  if (options.session) {
+    const timestamp = new Date().toISOString();
+    const sourceInfo = options.sessionSource ? ` source=${options.sessionSource}` : "";
+    finalText = `<!-- ${timestamp} session=${options.session}${sourceInfo} -->\n${text}`;
+  }
+
+  // Load config and create Minimem instance
+  const cliConfig = await loadConfig(memoryDir);
+  const config = buildMinimemConfig(memoryDir, cliConfig, {
+    provider: options.provider,
+    watch: false,
+  });
+
+  let minimem: Minimem | null = null;
+
+  try {
+    minimem = await Minimem.create(config);
+
+    let targetPath: string;
+
+    if (options.file) {
+      // Append to specific file
+      targetPath = options.file;
+      await minimem.appendFile(targetPath, finalText);
+    } else {
+      // Append to today's daily log
+      targetPath = await minimem.appendToday(finalText);
+    }
+
+    console.log(`Appended to ${targetPath}`);
+    if (options.session) {
+      console.log(`  Session: ${options.session}`);
+    }
+  } finally {
+    minimem?.close();
+  }
+}

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;
+}