macro-agent 0.1.0 → 0.1.2

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

@@ -0,0 +1,759 @@
+/**
+ * Tests for CLI commands
+ *
+ * These tests exercise the CLI command functions directly.
+ * Uses mock fetch for deterministic embeddings.
+ *
+ * Run with: npm run test:cli
+ */
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { after, afterEach, before, beforeEach, describe, it } from "node:test";
+import assert from "node:assert";
+
+import { init } from "../commands/init.js";
+import { search } from "../commands/search.js";
+import { sync } from "../commands/sync.js";
+import { status } from "../commands/status.js";
+import { append } from "../commands/append.js";
+import { upsert } from "../commands/upsert.js";
+import { config } from "../commands/config.js";
+import { ensureGlobalInitialized } from "../commands/mcp.js";
+import {
+  isInitialized,
+  expandPath,
+  getXdgConfigPath,
+  loadXdgConfig,
+  saveXdgConfig,
+  getMachineId,
+  getSyncConfig,
+  getDefaultSyncConfig,
+  getDefaultGlobalSyncConfig,
+  resolveMemoryDirs,
+  getDirName,
+  type GlobalConfig,
+} from "../config.js";
+import { createMockFetch, captureConsole } from "../../__tests__/helpers.js";
+
+describe("CLI Commands", () => {
+  let tempDir: string;
+  let originalFetch: typeof fetch;
+  let mockFetch: ReturnType<typeof createMockFetch>;
+  let originalExit: typeof process.exit;
+  let exitCode: number | undefined;
+
+  before(() => {
+    // Mock fetch globally
+    originalFetch = globalThis.fetch;
+    mockFetch = createMockFetch();
+    globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+    // Set API key for tests
+    process.env.OPENAI_API_KEY = "test-key";
+
+    // Mock process.exit to prevent test from exiting
+    originalExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCode = code;
+      throw new Error(`process.exit(${code})`);
+    }) as typeof process.exit;
+  });
+
+  after(() => {
+    globalThis.fetch = originalFetch;
+    delete process.env.OPENAI_API_KEY;
+    process.exit = originalExit;
+  });
+
+  beforeEach(async () => {
+    // Create fresh temp directory for each test
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-cli-test-"));
+    exitCode = undefined;
+  });
+
+  afterEach(async () => {
+    // Clean up temp directory
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("init command", () => {
+    it("should initialize a new memory directory", async () => {
+      const capture = captureConsole();
+
+      try {
+        await init(tempDir, { global: false, force: false });
+      } finally {
+        capture.restore();
+      }
+
+      // Check files were created
+      const memoryMd = await fs.readFile(path.join(tempDir, "MEMORY.md"), "utf-8");
+      assert.ok(memoryMd.includes("# Memory"), "MEMORY.md should have header");
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(config.embedding.provider, "auto");
+
+      const memoryDir = await fs.stat(path.join(tempDir, "memory"));
+      assert.ok(memoryDir.isDirectory(), "memory/ directory should exist");
+
+      // Check output
+      assert.ok(capture.logs.some(l => l.includes("Initializing")));
+      assert.ok(capture.logs.some(l => l.includes("Done!")));
+    });
+
+    it("should not reinitialize without --force", async () => {
+      // Initialize first
+      await init(tempDir, { global: false, force: false });
+
+      const capture = captureConsole();
+      try {
+        await init(tempDir, { global: false, force: false });
+      } finally {
+        capture.restore();
+      }
+
+      // Should indicate already initialized (logs to stdout, not stderr)
+      assert.ok(capture.logs.some(l => l.includes("Already initialized")));
+    });
+
+    it("should reinitialize with --force", async () => {
+      // Initialize first
+      await init(tempDir, { global: false, force: false });
+
+      // Modify MEMORY.md
+      await fs.writeFile(path.join(tempDir, "MEMORY.md"), "Custom content");
+
+      const capture = captureConsole();
+      try {
+        await init(tempDir, { global: false, force: true });
+      } finally {
+        capture.restore();
+      }
+
+      // Check MEMORY.md was NOT overwritten (force only resets config)
+      const memoryMd = await fs.readFile(path.join(tempDir, "MEMORY.md"), "utf-8");
+      assert.strictEqual(memoryMd, "Custom content");
+
+      assert.ok(capture.logs.some(l => l.includes("Done!")));
+    });
+  });
+
+  describe("upsert command", () => {
+    beforeEach(async () => {
+      // Initialize memory directory
+      await init(tempDir, { global: false, force: false });
+    });
+
+    it("should create a new file", async () => {
+      const capture = captureConsole();
+
+      try {
+        await upsert("test-note.md", "# Test Note\n\nThis is a test.", { dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      const content = await fs.readFile(path.join(tempDir, "test-note.md"), "utf-8");
+      assert.strictEqual(content, "# Test Note\n\nThis is a test.");
+      assert.ok(capture.logs.some(l => l.includes("Created")));
+    });
+
+    it("should update an existing file", async () => {
+      // Create file first
+      await fs.writeFile(path.join(tempDir, "existing.md"), "Old content");
+
+      const capture = captureConsole();
+
+      try {
+        await upsert("existing.md", "New content", { dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      const content = await fs.readFile(path.join(tempDir, "existing.md"), "utf-8");
+      assert.strictEqual(content, "New content");
+      assert.ok(capture.logs.some(l => l.includes("Updated")));
+    });
+
+    it("should create file in memory/ subdirectory", async () => {
+      const capture = captureConsole();
+
+      try {
+        await upsert("memory/notes.md", "# Notes", { dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      const content = await fs.readFile(path.join(tempDir, "memory", "notes.md"), "utf-8");
+      assert.strictEqual(content, "# Notes");
+    });
+
+    it("should reject paths outside memory directory", async () => {
+      const capture = captureConsole();
+
+      try {
+        await upsert("/tmp/outside.md", "Bad content", { dir: tempDir });
+        assert.fail("Should have exited");
+      } catch (e) {
+        // Expected
+      } finally {
+        capture.restore();
+      }
+
+      assert.ok(capture.errors.some(l => l.includes("must be within")));
+    });
+  });
+
+  describe("append command", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+    });
+
+    it("should append to today's daily log", async () => {
+      const capture = captureConsole();
+
+      try {
+        await append("Test entry 1", { dir: tempDir });
+        await append("Test entry 2", { dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      // Check today's log file
+      const today = new Date().toISOString().split("T")[0];
+      const logPath = path.join(tempDir, "memory", `${today}.md`);
+      const content = await fs.readFile(logPath, "utf-8");
+
+      assert.ok(content.includes("Test entry 1"));
+      assert.ok(content.includes("Test entry 2"));
+    });
+
+    it("should append to specific file with --file", async () => {
+      const capture = captureConsole();
+
+      try {
+        // Must use valid memory path (memory/*.md)
+        await append("Custom entry", { dir: tempDir, file: "memory/custom-log.md" });
+      } finally {
+        capture.restore();
+      }
+
+      const content = await fs.readFile(path.join(tempDir, "memory", "custom-log.md"), "utf-8");
+      assert.ok(content.includes("Custom entry"));
+    });
+  });
+
+  describe("sync command", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+
+      // Add some content to index
+      await fs.writeFile(
+        path.join(tempDir, "MEMORY.md"),
+        "# Memory\n\nImportant project decisions here."
+      );
+      await fs.writeFile(
+        path.join(tempDir, "memory", "notes.md"),
+        "# Notes\n\nMeeting notes about the API design."
+      );
+    });
+
+    it("should sync memory files", async () => {
+      const capture = captureConsole();
+
+      try {
+        await sync({ dir: tempDir, force: false });
+      } finally {
+        capture.restore();
+      }
+
+      assert.ok(capture.logs.some(l => l.includes("Syncing")));
+      assert.ok(capture.logs.some(l => l.includes("Files:") || l.includes("Chunks:")));
+    });
+
+    it("should force full re-index with --force", async () => {
+      // First sync
+      await sync({ dir: tempDir, force: false });
+
+      const capture = captureConsole();
+
+      try {
+        await sync({ dir: tempDir, force: true });
+      } finally {
+        capture.restore();
+      }
+
+      // Force sync should complete and show results
+      assert.ok(capture.logs.some(l => l.includes("Sync complete")));
+      assert.ok(capture.logs.some(l => l.includes("Files:")));
+    });
+  });
+
+  describe("status command", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+      await fs.writeFile(
+        path.join(tempDir, "MEMORY.md"),
+        "# Memory\n\nTest content."
+      );
+    });
+
+    it("should show index status", async () => {
+      const capture = captureConsole();
+
+      try {
+        await status({ dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      assert.ok(capture.logs.some(l => l.includes("Provider") || l.includes("provider")));
+      assert.ok(capture.logs.some(l => l.includes("Files") || l.includes("files")));
+    });
+
+    it("should output JSON with --json flag", async () => {
+      const capture = captureConsole();
+
+      try {
+        await status({ dir: tempDir, json: true });
+      } finally {
+        capture.restore();
+      }
+
+      // Should have valid JSON output
+      const jsonOutput = capture.logs.find(l => l.startsWith("{"));
+      assert.ok(jsonOutput, "Should have JSON output");
+
+      const parsed = JSON.parse(jsonOutput);
+      assert.ok("provider" in parsed || "files" in parsed || "chunks" in parsed);
+    });
+  });
+
+  describe("search command", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+
+      // Create searchable content
+      await fs.writeFile(
+        path.join(tempDir, "MEMORY.md"),
+        `# Memory
+
+## Project Decisions
+We decided to use PostgreSQL for the database.
+The API will use REST endpoints.
+
+## Meeting Notes
+Important meeting about project planning.
+`
+      );
+
+      await fs.writeFile(
+        path.join(tempDir, "memory", "bugs.md"),
+        `# Bug Tracker
+
+## Bug #1: Login Error
+Users report login errors when password contains special characters.
+This is an urgent bug fix needed.
+`
+      );
+
+      // Sync to index the content
+      await sync({ dir: tempDir, force: false });
+    });
+
+    it("should search memory files", async () => {
+      const capture = captureConsole();
+
+      try {
+        await search("database decision", { dir: [tempDir] });
+      } finally {
+        capture.restore();
+      }
+
+      // Should find results
+      assert.ok(
+        capture.logs.some(l => l.includes("result") || l.includes("%")),
+        "Should show search results"
+      );
+    });
+
+    it("should output JSON with --json flag", async () => {
+      const capture = captureConsole();
+
+      try {
+        await search("project", { dir: [tempDir], json: true });
+      } finally {
+        capture.restore();
+      }
+
+      const jsonOutput = capture.logs.find(l => l.startsWith("["));
+      assert.ok(jsonOutput, "Should have JSON array output");
+
+      const results = JSON.parse(jsonOutput);
+      assert.ok(Array.isArray(results));
+    });
+
+    it("should respect --max option", async () => {
+      const capture = captureConsole();
+
+      try {
+        await search("project", { dir: [tempDir], max: "1" });
+      } finally {
+        capture.restore();
+      }
+
+      // Count result entries (lines with percentage scores)
+      const resultLines = capture.logs.filter(l => l.match(/\[\d+\.\d+%\]/));
+      assert.ok(resultLines.length <= 1, "Should have at most 1 result");
+    });
+
+    it("should search multiple directories", async () => {
+      // Create second memory directory
+      const tempDir2 = await fs.mkdtemp(path.join(os.tmpdir(), "minimem-cli-test2-"));
+
+      try {
+        await init(tempDir2, { global: false, force: false });
+        await fs.writeFile(
+          path.join(tempDir2, "MEMORY.md"),
+          "# Second Memory\n\nDifferent project notes about testing."
+        );
+        await sync({ dir: tempDir2, force: false });
+
+        const capture = captureConsole();
+
+        try {
+          await search("project", { dir: [tempDir, tempDir2] });
+        } finally {
+          capture.restore();
+        }
+
+        // Should mention searching multiple directories
+        assert.ok(
+          capture.logs.some(l => l.includes("directories") || l.includes("result")),
+          "Should search across directories"
+        );
+      } finally {
+        await fs.rm(tempDir2, { recursive: true, force: true });
+      }
+    });
+
+    it("should warn about uninitialized directories", async () => {
+      const capture = captureConsole();
+      const nonExistent = path.join(tempDir, "nonexistent");
+
+      try {
+        await search("test", { dir: [tempDir, nonExistent] });
+      } finally {
+        capture.restore();
+      }
+
+      assert.ok(
+        capture.errors.some(l => l.includes("not initialized") || l.includes("skipping")),
+        "Should warn about uninitialized directory"
+      );
+    });
+  });
+
+  describe("mcp command helpers", () => {
+    describe("resolveMemoryDirs", () => {
+      it("should use current directory by default", () => {
+        const dirs = resolveMemoryDirs({});
+        assert.strictEqual(dirs.length, 1);
+        assert.strictEqual(dirs[0], process.cwd());
+      });
+
+      it("should use specified directories", () => {
+        const dirs = resolveMemoryDirs({ dir: ["/path/one", "/path/two"] });
+        assert.strictEqual(dirs.length, 2);
+        assert.ok(dirs[0].endsWith("one"));
+        assert.ok(dirs[1].endsWith("two"));
+      });
+
+      it("should add global directory with --global flag", () => {
+        const dirs = resolveMemoryDirs({ global: true });
+        assert.strictEqual(dirs.length, 1);
+        assert.ok(dirs[0].endsWith(".minimem"), "Should include global directory");
+      });
+
+      it("should combine --dir and --global", () => {
+        const dirs = resolveMemoryDirs({ dir: ["/path/project"], global: true });
+        assert.strictEqual(dirs.length, 2);
+        assert.ok(dirs[0].endsWith("project"));
+        assert.ok(dirs[1].endsWith(".minimem"));
+      });
+
+      it("should not duplicate global directory", () => {
+        const globalPath = path.join(os.homedir(), ".minimem");
+        const dirs = resolveMemoryDirs({ dir: [globalPath], global: true });
+        assert.strictEqual(dirs.length, 1);
+        assert.strictEqual(dirs[0], globalPath);
+      });
+    });
+
+    describe("getDirName", () => {
+      it("should return 'global' for ~/.minimem", () => {
+        const globalDir = path.join(os.homedir(), ".minimem");
+        assert.strictEqual(getDirName(globalDir), "global");
+      });
+
+      it("should return directory name for regular paths", () => {
+        assert.strictEqual(getDirName("/path/to/my-project"), "my-project");
+      });
+
+      it("should include parent for hidden directories", () => {
+        const name = getDirName("/path/to/project/.hidden");
+        assert.ok(name.includes("project"));
+        assert.ok(name.includes(".hidden"));
+      });
+    });
+
+    describe("ensureGlobalInitialized", () => {
+      it("should create global directory structure", async () => {
+        const fakeGlobalDir = path.join(tempDir, ".fake-minimem");
+
+        const capture = captureConsole();
+        try {
+          await ensureGlobalInitialized(fakeGlobalDir);
+        } finally {
+          capture.restore();
+        }
+
+        // Check directory was created
+        assert.ok(await isInitialized(fakeGlobalDir), "Should be initialized");
+
+        // Check MEMORY.md exists with global template
+        const memoryMd = await fs.readFile(path.join(fakeGlobalDir, "MEMORY.md"), "utf-8");
+        assert.ok(memoryMd.includes("Global Memory"), "Should have global template");
+
+        // Check config exists
+        const configPath = path.join(fakeGlobalDir, ".minimem", "config.json");
+        const configData = JSON.parse(await fs.readFile(configPath, "utf-8"));
+        assert.strictEqual(configData.embedding.provider, "auto");
+
+        // Check .gitignore exists
+        const gitignore = await fs.readFile(
+          path.join(fakeGlobalDir, ".minimem", ".gitignore"),
+          "utf-8"
+        );
+        assert.ok(gitignore.includes("index.db"));
+
+        // Check output messages
+        assert.ok(capture.errors.some(l => l.includes("Auto-initializing")));
+        assert.ok(capture.errors.some(l => l.includes("Created")));
+      });
+
+      it("should not overwrite existing MEMORY.md", async () => {
+        const fakeGlobalDir = path.join(tempDir, ".fake-minimem2");
+
+        // Pre-create with custom content
+        await fs.mkdir(fakeGlobalDir, { recursive: true });
+        await fs.writeFile(path.join(fakeGlobalDir, "MEMORY.md"), "My custom content");
+
+        const capture = captureConsole();
+        try {
+          await ensureGlobalInitialized(fakeGlobalDir);
+        } finally {
+          capture.restore();
+        }
+
+        // Check MEMORY.md was preserved
+        const memoryMd = await fs.readFile(path.join(fakeGlobalDir, "MEMORY.md"), "utf-8");
+        assert.strictEqual(memoryMd, "My custom content", "Should preserve existing MEMORY.md");
+      });
+    });
+  });
+
+  describe("config utilities", () => {
+    describe("expandPath", () => {
+      it("should expand ~ to home directory", () => {
+        const expanded = expandPath("~/test/path");
+        assert.strictEqual(expanded, path.join(os.homedir(), "test/path"));
+      });
+
+      it("should expand lone ~", () => {
+        const expanded = expandPath("~");
+        assert.strictEqual(expanded, os.homedir());
+      });
+
+      it("should not modify paths without ~", () => {
+        const expanded = expandPath("/absolute/path");
+        assert.strictEqual(expanded, "/absolute/path");
+      });
+
+      it("should not expand ~ in the middle of path", () => {
+        const expanded = expandPath("/some/~path");
+        assert.strictEqual(expanded, "/some/~path");
+      });
+    });
+
+    describe("getDefaultSyncConfig", () => {
+      it("should return default sync configuration", () => {
+        const defaults = getDefaultSyncConfig();
+        assert.strictEqual(defaults.enabled, false);
+        assert.deepStrictEqual(defaults.include, ["MEMORY.md", "memory/**/*.md"]);
+        assert.deepStrictEqual(defaults.exclude, []);
+      });
+    });
+
+    describe("getDefaultGlobalSyncConfig", () => {
+      it("should return default global sync configuration", () => {
+        const defaults = getDefaultGlobalSyncConfig();
+        assert.strictEqual(defaults.conflictStrategy, "keep-both");
+        assert.strictEqual(defaults.autoSync, false);
+        assert.strictEqual(defaults.autoCommit, false);
+      });
+    });
+  });
+
+  describe("hooks config", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+    });
+
+    it("should set hooks.sessionStart via config command", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "hooks.sessionStart=true" });
+      } finally {
+        capture.restore();
+      }
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.hooks?.sessionStart, true);
+    });
+
+    it("should set hooks.sessionEnd via config command", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "hooks.sessionEnd=true" });
+      } finally {
+        capture.restore();
+      }
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.hooks?.sessionEnd, true);
+    });
+
+    it("should disable hooks via config command", async () => {
+      // First enable
+      await config({ dir: tempDir, set: "hooks.sessionStart=true" });
+
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "hooks.sessionStart=false" });
+      } finally {
+        capture.restore();
+      }
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.hooks?.sessionStart, false);
+    });
+
+    it("should set both hooks independently", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "hooks.sessionStart=true" });
+        await config({ dir: tempDir, set: "hooks.sessionEnd=false" });
+      } finally {
+        capture.restore();
+      }
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.hooks?.sessionStart, true);
+      assert.strictEqual(savedConfig.hooks?.sessionEnd, false);
+    });
+  });
+
+  describe("sync config", () => {
+    beforeEach(async () => {
+      await init(tempDir, { global: false, force: false });
+    });
+
+    it("should set sync.enabled via config command", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "sync.enabled=true" });
+      } finally {
+        capture.restore();
+      }
+
+      // Verify the config was set
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.sync?.enabled, true);
+    });
+
+    it("should set sync.path via config command", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir, set: "sync.path=myproject/" });
+      } finally {
+        capture.restore();
+      }
+
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const savedConfig = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      assert.strictEqual(savedConfig.sync?.path, "myproject/");
+    });
+
+    it("should get sync config with defaults", async () => {
+      const syncConfig = await getSyncConfig(tempDir);
+
+      // Should have defaults applied
+      assert.strictEqual(syncConfig.enabled, false);
+      assert.deepStrictEqual(syncConfig.include, ["MEMORY.md", "memory/**/*.md"]);
+      assert.strictEqual(syncConfig.conflictStrategy, "keep-both");
+      assert.strictEqual(syncConfig.autoSync, false);
+    });
+
+    it("should merge local sync config with defaults", async () => {
+      // Set some local config
+      const configPath = path.join(tempDir, ".minimem", "config.json");
+      const localConfig = {
+        embedding: { provider: "auto" },
+        sync: {
+          enabled: true,
+          path: "test-project/",
+          include: ["MEMORY.md", "custom/**/*.md"],
+        },
+      };
+      await fs.writeFile(configPath, JSON.stringify(localConfig, null, 2));
+
+      const syncConfig = await getSyncConfig(tempDir);
+
+      assert.strictEqual(syncConfig.enabled, true);
+      assert.strictEqual(syncConfig.path, "test-project/");
+      assert.deepStrictEqual(syncConfig.include, ["MEMORY.md", "custom/**/*.md"]);
+      // Defaults still applied for unset values
+      assert.strictEqual(syncConfig.conflictStrategy, "keep-both");
+    });
+
+    it("should display sync config in config command output", async () => {
+      const capture = captureConsole();
+
+      try {
+        await config({ dir: tempDir });
+      } finally {
+        capture.restore();
+      }
+
+      // Should show sync sections
+      assert.ok(capture.logs.some(l => l.includes("Sync (Local)")));
+      assert.ok(capture.logs.some(l => l.includes("Sync (Global)")));
+      assert.ok(capture.logs.some(l => l.includes("conflictStrategy")));
+    });
+  });
+});