/**
* Tests for Platform Registry
*
* @module @agentkits/memory/cli/__tests__/platforms.test
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import * as fs from 'node:fs';
import * as path from 'node:path';
import * as os from 'node:os';
import {
PLATFORMS,
ALL_PLATFORM_IDS,
detectPlatforms,
resolvePlatforms,
type PlatformId,
} from '../platforms.js';
describe('Platform Registry', () => {
// ===== PLATFORMS constant =====
describe('PLATFORMS', () => {
it('should define all 5 platforms', () => {
expect(ALL_PLATFORM_IDS).toHaveLength(5);
expect(ALL_PLATFORM_IDS).toContain('claude-code');
expect(ALL_PLATFORM_IDS).toContain('cursor');
expect(ALL_PLATFORM_IDS).toContain('windsurf');
expect(ALL_PLATFORM_IDS).toContain('cline');
expect(ALL_PLATFORM_IDS).toContain('opencode');
});
it('should have valid configDir for each platform', () => {
for (const platform of Object.values(PLATFORMS)) {
expect(platform.configDir).toBeTruthy();
expect(platform.configDir.startsWith('.')).toBe(true);
}
});
it('should have valid mcpConfigPath for each platform', () => {
for (const platform of Object.values(PLATFORMS)) {
expect(platform.mcpConfigPath).toBeTruthy();
expect(platform.mcpConfigPath).toMatch(/\.(json)$/);
}
});
it('should mark claude-code and opencode as supporting hooks', () => {
expect(PLATFORMS['claude-code'].supportsHooks).toBe(true);
expect(PLATFORMS.opencode.supportsHooks).toBe(true);
});
it('should mark cursor, windsurf, cline as not supporting hooks', () => {
expect(PLATFORMS.cursor.supportsHooks).toBe(false);
expect(PLATFORMS.windsurf.supportsHooks).toBe(false);
expect(PLATFORMS.cline.supportsHooks).toBe(false);
});
it('should have rules files for cursor, windsurf, cline', () => {
expect(PLATFORMS.cursor.rulesFile).toBe('.cursorrules');
expect(PLATFORMS.windsurf.rulesFile).toBe('.windsurfrules');
expect(PLATFORMS.cline.rulesFile).toBe('.clinerules');
});
it('should not have rules files for claude-code and opencode', () => {
expect(PLATFORMS['claude-code'].rulesFile).toBeNull();
expect(PLATFORMS.opencode.rulesFile).toBeNull();
});
it('should only have skillsDir for claude-code', () => {
expect(PLATFORMS['claude-code'].skillsDir).toBe('.claude/skills');
expect(PLATFORMS.cursor.skillsDir).toBeNull();
expect(PLATFORMS.windsurf.skillsDir).toBeNull();
expect(PLATFORMS.cline.skillsDir).toBeNull();
expect(PLATFORMS.opencode.skillsDir).toBeNull();
});
it('should use embedded mcpConfigFormat only for claude-code', () => {
expect(PLATFORMS['claude-code'].mcpConfigFormat).toBe('embedded');
expect(PLATFORMS.cursor.mcpConfigFormat).toBe('standalone');
expect(PLATFORMS.windsurf.mcpConfigFormat).toBe('standalone');
expect(PLATFORMS.cline.mcpConfigFormat).toBe('standalone');
expect(PLATFORMS.opencode.mcpConfigFormat).toBe('standalone');
});
});
// ===== detectPlatforms =====
describe('detectPlatforms', () => {
let tmpDir: string;
beforeEach(() => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'platforms-test-'));
});
afterEach(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('should return empty array for empty directory', () => {
expect(detectPlatforms(tmpDir)).toEqual([]);
});
it('should detect claude-code from .claude directory', () => {
fs.mkdirSync(path.join(tmpDir, '.claude'));
const detected = detectPlatforms(tmpDir);
expect(detected).toContain('claude-code');
});
it('should detect cursor from .cursor directory', () => {
fs.mkdirSync(path.join(tmpDir, '.cursor'));
const detected = detectPlatforms(tmpDir);
expect(detected).toContain('cursor');
});
it('should detect multiple platforms', () => {
fs.mkdirSync(path.join(tmpDir, '.claude'));
fs.mkdirSync(path.join(tmpDir, '.cursor'));
fs.mkdirSync(path.join(tmpDir, '.windsurf'));
const detected = detectPlatforms(tmpDir);
expect(detected).toContain('claude-code');
expect(detected).toContain('cursor');
expect(detected).toContain('windsurf');
expect(detected).toHaveLength(3);
});
it('should detect all 5 platforms when all present', () => {
for (const platform of Object.values(PLATFORMS)) {
fs.mkdirSync(path.join(tmpDir, platform.configDir));
}
const detected = detectPlatforms(tmpDir);
expect(detected).toHaveLength(5);
});
});
// ===== resolvePlatforms =====
describe('resolvePlatforms', () => {
let tmpDir: string;
beforeEach(() => {
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'platforms-test-'));
});
afterEach(() => {
fs.rmSync(tmpDir, { recursive: true, force: true });
});
it('should return all platforms for "all"', () => {
const result = resolvePlatforms('all', tmpDir);
expect(result).toEqual(ALL_PLATFORM_IDS);
});
it('should return single platform for "cursor"', () => {
const result = resolvePlatforms('cursor', tmpDir);
expect(result).toEqual(['cursor']);
});
it('should return multiple platforms for comma-separated list', () => {
const result = resolvePlatforms('cursor,windsurf', tmpDir);
expect(result).toEqual(['cursor', 'windsurf']);
});
it('should filter invalid platform names', () => {
const result = resolvePlatforms('cursor,invalid,windsurf', tmpDir);
expect(result).toEqual(['cursor', 'windsurf']);
});
it('should fall back to auto-detect when all names are invalid', () => {
fs.mkdirSync(path.join(tmpDir, '.cursor'));
const result = resolvePlatforms('invalid', tmpDir);
expect(result).toContain('cursor');
});
it('should auto-detect when no platformArg is given', () => {
fs.mkdirSync(path.join(tmpDir, '.cursor'));
fs.mkdirSync(path.join(tmpDir, '.claude'));
const result = resolvePlatforms(undefined, tmpDir);
expect(result).toContain('claude-code');
expect(result).toContain('cursor');
});
it('should default to claude-code when nothing detected', () => {
const result = resolvePlatforms(undefined, tmpDir);
expect(result).toEqual(['claude-code']);
});
it('should handle empty string by auto-detecting', () => {
const result = resolvePlatforms('', tmpDir);
// Empty string is falsy so falls through to auto-detect
expect(result).toEqual(['claude-code']);
});
});
});
