@unifiedmemory/cli 1.3.1 → 1.3.7

package/tests/unit/provider-detector.test.js

@@ -0,0 +1,344 @@
+/**
+ * Unit tests for lib/provider-detector.js
+ *
+ * Tests AI code assistant provider detection and configuration.
+ * Uses temporary directories to simulate different provider installations.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+// Create temp directories for testing
+const TEST_HOME = path.join(os.tmpdir(), `um-cli-test-home-${Date.now()}`);
+const TEST_PROJECT = path.join(os.tmpdir(), `um-cli-test-project-${Date.now()}`);
+
+describe('provider-detector', () => {
+  beforeEach(async () => {
+    // Create test directories
+    await fs.ensureDir(TEST_HOME);
+    await fs.ensureDir(TEST_PROJECT);
+
+    // Reset modules for fresh imports
+    vi.resetModules();
+  });
+
+  afterEach(async () => {
+    // Clean up test directories
+    await fs.remove(TEST_HOME);
+    await fs.remove(TEST_PROJECT);
+    vi.restoreAllMocks();
+  });
+
+  describe('ProviderDetector', () => {
+    it('should export ProviderDetector class', async () => {
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      expect(ProviderDetector).toBeDefined();
+      expect(typeof ProviderDetector).toBe('function');
+    });
+
+    it('should create detector with project directory', async () => {
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+
+      expect(detector).toBeDefined();
+      expect(detector.providers).toBeDefined();
+      expect(Array.isArray(detector.providers)).toBe(true);
+    });
+
+    it('should detect no providers when directories do not exist', async () => {
+      // Mock homedir to use our empty test directory
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+
+      // Fresh import after mock
+      vi.resetModules();
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+      const detected = detector.detectAll();
+
+      // Claude Code always detects as true (project-level config)
+      const nonClaudeDetected = detected.filter(p => p.name !== 'Claude Code');
+      expect(nonClaudeDetected.length).toBe(0);
+    });
+
+    it('should detect Cursor when .cursor directory exists', async () => {
+      // Create Cursor directory
+      const cursorDir = path.join(TEST_HOME, '.cursor');
+      await fs.ensureDir(cursorDir);
+
+      // Mock homedir to use our test directory
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+
+      // Fresh import after mock
+      vi.resetModules();
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+      const cursorProvider = detector.getByName('Cursor');
+
+      expect(cursorProvider).toBeDefined();
+      expect(cursorProvider.detect()).toBe(true);
+    });
+
+    it('should detect Cline when .cline directory exists', async () => {
+      // Create Cline directory
+      const clineDir = path.join(TEST_HOME, '.cline');
+      await fs.ensureDir(clineDir);
+
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+      vi.resetModules();
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+      const clineProvider = detector.getByName('Cline');
+
+      expect(clineProvider).toBeDefined();
+      expect(clineProvider.detect()).toBe(true);
+    });
+
+    it('should detect Codex CLI when .codex directory exists', async () => {
+      // Create Codex directory
+      const codexDir = path.join(TEST_HOME, '.codex');
+      await fs.ensureDir(codexDir);
+
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+      vi.resetModules();
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+      const codexProvider = detector.getByName('Codex CLI');
+
+      expect(codexProvider).toBeDefined();
+      expect(codexProvider.detect()).toBe(true);
+    });
+
+    it('should detect Gemini CLI when .gemini directory exists', async () => {
+      // Create Gemini directory
+      const geminiDir = path.join(TEST_HOME, '.gemini');
+      await fs.ensureDir(geminiDir);
+
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+      vi.resetModules();
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+      const geminiProvider = detector.getByName('Gemini CLI');
+
+      expect(geminiProvider).toBeDefined();
+      expect(geminiProvider.detect()).toBe(true);
+    });
+
+    it('should find provider by name case-insensitively', async () => {
+      const { ProviderDetector } = await import('../../lib/provider-detector.js');
+
+      const detector = new ProviderDetector(TEST_PROJECT);
+
+      expect(detector.getByName('claude code')).toBeDefined();
+      expect(detector.getByName('CLAUDE CODE')).toBeDefined();
+      expect(detector.getByName('Claude Code')).toBeDefined();
+    });
+  });
+
+  describe('ClaudeProvider', () => {
+    it('should always detect as available (project-level config)', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+
+      expect(provider.detect()).toBe(true);
+    });
+
+    it('should configure MCP server in .mcp.json', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+      const success = provider.configureMCP();
+
+      expect(success).toBe(true);
+
+      // Verify .mcp.json was created
+      const mcpConfigPath = path.join(TEST_PROJECT, '.mcp.json');
+      expect(fs.existsSync(mcpConfigPath)).toBe(true);
+
+      const config = fs.readJSONSync(mcpConfigPath);
+      expect(config.mcpServers.unifiedmemory).toEqual({
+        command: 'um',
+        args: ['mcp', 'serve'],
+      });
+    });
+
+    it('should update Claude settings with tool permissions', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+      const permissions = ['mcp__unifiedmemory__create_note', 'mcp__unifiedmemory__search_notes'];
+
+      provider.configureMCP(permissions);
+
+      // Verify settings were created
+      const settingsPath = path.join(TEST_PROJECT, '.claude', 'settings.local.json');
+      expect(fs.existsSync(settingsPath)).toBe(true);
+
+      const settings = fs.readJSONSync(settingsPath);
+      expect(settings.enableAllProjectMcpServers).toBe(true);
+      expect(settings.enabledMcpjsonServers).toContain('unifiedmemory');
+      expect(settings.permissions.allow).toContain('mcp__unifiedmemory__create_note');
+      expect(settings.permissions.allow).toContain('mcp__unifiedmemory__search_notes');
+    });
+
+    it('should merge with existing Claude settings', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      // Create existing settings
+      const claudeDir = path.join(TEST_PROJECT, '.claude');
+      await fs.ensureDir(claudeDir);
+      const settingsPath = path.join(claudeDir, 'settings.local.json');
+      fs.writeJSONSync(settingsPath, {
+        existingSetting: true,
+        permissions: {
+          allow: ['existing_permission'],
+        },
+      });
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+      provider.configureMCP(['mcp__unifiedmemory__new_tool']);
+
+      const settings = fs.readJSONSync(settingsPath);
+      expect(settings.existingSetting).toBe(true);
+      expect(settings.permissions.allow).toContain('existing_permission');
+      expect(settings.permissions.allow).toContain('mcp__unifiedmemory__new_tool');
+    });
+  });
+
+  describe('CursorProvider', () => {
+    it('should configure MCP in ~/.cursor/mcp.json', async () => {
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+
+      // Create Cursor directory
+      const cursorDir = path.join(TEST_HOME, '.cursor');
+      await fs.ensureDir(cursorDir);
+
+      vi.resetModules();
+      const { CursorProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new CursorProvider();
+      const success = provider.configureMCP();
+
+      expect(success).toBe(true);
+
+      const mcpConfigPath = path.join(cursorDir, 'mcp.json');
+      expect(fs.existsSync(mcpConfigPath)).toBe(true);
+
+      const config = fs.readJSONSync(mcpConfigPath);
+      expect(config.mcpServers.unifiedmemory).toEqual({
+        command: 'um',
+        args: ['mcp', 'serve'],
+      });
+    });
+  });
+
+  describe('CodexProvider', () => {
+    it('should configure MCP in TOML format', async () => {
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+
+      // Create Codex directory
+      const codexDir = path.join(TEST_HOME, '.codex');
+      await fs.ensureDir(codexDir);
+
+      vi.resetModules();
+      const { CodexProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new CodexProvider();
+      const success = provider.configureMCP();
+
+      expect(success).toBe(true);
+
+      const configPath = path.join(codexDir, 'config.toml');
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      const content = fs.readFileSync(configPath, 'utf8');
+      // TOML should contain the MCP server config
+      expect(content).toContain('[mcp_servers.unifiedmemory]');
+      expect(content).toContain('command = "um"');
+    });
+
+    it('should read existing TOML config', async () => {
+      vi.spyOn(os, 'homedir').mockReturnValue(TEST_HOME);
+
+      const codexDir = path.join(TEST_HOME, '.codex');
+      await fs.ensureDir(codexDir);
+
+      // Write existing TOML config
+      const existingToml = `
+[existing_setting]
+value = true
+
+[mcp_servers.other_server]
+command = "other"
+`;
+      fs.writeFileSync(path.join(codexDir, 'config.toml'), existingToml);
+
+      vi.resetModules();
+      const { CodexProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new CodexProvider();
+      const config = provider.readConfig();
+
+      expect(config.existing_setting.value).toBe(true);
+      expect(config.mcp_servers.other_server.command).toBe('other');
+    });
+  });
+
+  describe('Memory Instructions', () => {
+    it('should create CLAUDE.md with memory instructions', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+      const result = provider.configureMemoryInstructions();
+
+      expect(result.status).toBe('created');
+
+      const claudeMdPath = path.join(TEST_PROJECT, 'CLAUDE.md');
+      expect(fs.existsSync(claudeMdPath)).toBe(true);
+
+      const content = fs.readFileSync(claudeMdPath, 'utf8');
+      expect(content).toContain('UnifiedMemory');
+    });
+
+    it('should skip if memory instructions already present', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+
+      // First call creates
+      provider.configureMemoryInstructions();
+
+      // Second call should skip
+      const result = provider.configureMemoryInstructions();
+
+      expect(result.status).toBe('skipped');
+      expect(result.reason).toBe('already_present');
+    });
+
+    it('should append to existing file without marker', async () => {
+      const { ClaudeProvider } = await import('../../lib/provider-detector.js');
+
+      // Create existing CLAUDE.md without marker
+      const claudeMdPath = path.join(TEST_PROJECT, 'CLAUDE.md');
+      fs.writeFileSync(claudeMdPath, '# Existing Content\n\nSome existing instructions.');
+
+      const provider = new ClaudeProvider(TEST_PROJECT);
+      const result = provider.configureMemoryInstructions();
+
+      expect(result.status).toBe('appended');
+
+      const content = fs.readFileSync(claudeMdPath, 'utf8');
+      expect(content).toContain('# Existing Content');
+      expect(content).toContain('UnifiedMemory');
+    });
+  });
+});

package/tests/unit/token-storage.test.js

@@ -0,0 +1,138 @@
+/**
+ * Unit tests for lib/token-storage.js
+ *
+ * Tests token storage mock factory and module interface.
+ *
+ * Note: Direct testing of token-storage.js filesystem operations is complex
+ * due to hardcoded paths using os.homedir(). Instead, we test:
+ * 1. The mock factory that simulates token storage behavior
+ * 2. The module exports (verifying the interface exists)
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+// Test the mock factory from our test utilities
+describe('token-storage mock', () => {
+  it('should provide mock implementations that work correctly', async () => {
+    const { createTokenStorageMock, mockAuthData } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createTokenStorageMock();
+
+    // getToken returns initial mock data
+    expect(mock.getToken()).toEqual(mockAuthData);
+
+    // saveToken updates the data
+    const newData = { accessToken: 'new_token', decoded: { sub: 'user_new' } };
+    mock.saveToken(newData);
+    expect(mock.getToken()).toEqual(newData);
+
+    // clearToken removes the data
+    mock.clearToken();
+    expect(mock.getToken()).toBeNull();
+  });
+
+  it('should provide empty token storage mock', async () => {
+    const { createEmptyTokenStorageMock } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createEmptyTokenStorageMock();
+
+    expect(mock.getToken()).toBeNull();
+  });
+
+  it('should provide expired token storage mock', async () => {
+    const { createExpiredTokenStorageMock, expiredAuthData } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createExpiredTokenStorageMock();
+
+    const token = mock.getToken();
+    expect(token).toEqual(expiredAuthData);
+
+    // Verify the token is actually expired (exp is in the past)
+    const now = Math.floor(Date.now() / 1000);
+    expect(token.decoded.exp).toBeLessThan(now);
+  });
+
+  it('should track saveToken calls', async () => {
+    const { createTokenStorageMock } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createTokenStorageMock();
+
+    mock.saveToken({ accessToken: 'token1' });
+    mock.saveToken({ accessToken: 'token2' });
+
+    expect(mock.saveToken).toHaveBeenCalledTimes(2);
+    expect(mock.saveToken).toHaveBeenLastCalledWith({ accessToken: 'token2' });
+  });
+
+  it('should handle updateSelectedOrg correctly', async () => {
+    const { createTokenStorageMock } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createTokenStorageMock();
+
+    const newOrg = { id: 'org_new', name: 'New Org', role: 'member' };
+    mock.updateSelectedOrg(newOrg);
+
+    expect(mock.updateSelectedOrg).toHaveBeenCalledWith(newOrg);
+    expect(mock.getToken().selectedOrg).toEqual(newOrg);
+  });
+
+  it('should throw error when updating org with no token', async () => {
+    const { createEmptyTokenStorageMock } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createEmptyTokenStorageMock();
+
+    expect(() => mock.updateSelectedOrg({ id: 'org_123' })).toThrow('No token found');
+  });
+
+  it('should allow resetting state via _reset helper', async () => {
+    const { createTokenStorageMock, mockAuthData } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createTokenStorageMock();
+
+    // Clear token
+    mock.clearToken();
+    expect(mock.getToken()).toBeNull();
+
+    // Reset to default
+    mock._reset();
+    expect(mock.getToken()).toEqual(mockAuthData);
+
+    // Reset to custom data
+    const customData = { accessToken: 'custom' };
+    mock._reset(customData);
+    expect(mock.getToken()).toEqual(customData);
+  });
+
+  it('should provide getSelectedOrg that returns org from token', async () => {
+    const { createTokenStorageMock, mockAuthData } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createTokenStorageMock();
+
+    expect(mock.getSelectedOrg()).toEqual(mockAuthData.selectedOrg);
+  });
+
+  it('should return null from getSelectedOrg when no token', async () => {
+    const { createEmptyTokenStorageMock } = await import('../mocks/token-storage.mock.js');
+
+    const mock = createEmptyTokenStorageMock();
+
+    expect(mock.getSelectedOrg()).toBeNull();
+  });
+});
+
+// Direct tests for the actual token-storage module behavior
+describe('token-storage module behavior', () => {
+  // These tests verify the actual module behavior by directly testing
+  // specific aspects that don't require mocking the path
+
+  it('should export all required functions', async () => {
+    vi.resetModules();
+    const ts = await import('../../lib/token-storage.js');
+
+    expect(typeof ts.saveToken).toBe('function');
+    expect(typeof ts.getToken).toBe('function');
+    expect(typeof ts.clearToken).toBe('function');
+    expect(typeof ts.updateSelectedOrg).toBe('function');
+    expect(typeof ts.getSelectedOrg).toBe('function');
+  });
+});

package/vitest.config.js

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    // Use Node.js environment
+    environment: 'node',
+
+    // Global test setup
+    setupFiles: ['./tests/setup.js'],
+
+    // Test file patterns
+    include: ['tests/**/*.test.js'],
+
+    // Coverage configuration
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html', 'lcov'],
+      include: ['lib/**/*.js', 'commands/**/*.js'],
+      exclude: [
+        'node_modules/**',
+        'tests/**',
+        '**/*.test.js',
+      ],
+    },
+
+    // Timeout for tests (10 seconds)
+    testTimeout: 10000,
+
+    // Run tests in sequence for consistent filesystem state
+    sequence: {
+      shuffle: false,
+    },
+
+    // Disable watch mode in CI
+    watch: false,
+  },
+});