feat: introduce sdk commands

packages/cli/__tests__/commands/mcp.test.ts

@@ -0,0 +1,139 @@
+import yargs from 'yargs';
+import { buildTestJwt } from '@spotify-confidence/testing/auth';
+import { prepareAuthTokens } from '@spotify-confidence/testing/auth';
+import { mcpCommand } from '@commands/mcp.js';
+import { captureOutput } from '../helpers/capture.js';
+import { createMockIntegration } from '../helpers/mock-integration.js';
+
+const mockIntegration = createMockIntegration({
+  detectMcpStatuses: vi.fn().mockResolvedValue({
+    'confidence-flags': 'connected',
+    'confidence-docs': 'connected',
+  }),
+});
+
+const mockAuthenticate = vi.fn().mockResolvedValue({
+  accessToken: buildTestJwt({ email: 'test@example.com' }),
+  region: 'EU',
+});
+
+vi.mock('@spotify-confidence/core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@spotify-confidence/core')>();
+  return {
+    ...actual,
+    getIntegration: () => mockIntegration,
+    getIntegrations: () => [mockIntegration],
+    authenticate: (...args: unknown[]) => mockAuthenticate(...args),
+  };
+});
+
+vi.mock('@inquirer/select', () => ({
+  default: vi.fn().mockResolvedValue('claude'),
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+function run(args: string[]) {
+  return yargs(args)
+    .option('json', { type: 'boolean', default: false })
+    .option('output', { type: 'string' })
+    .command(mcpCommand)
+    .parse();
+}
+
+describe('mcp list', () => {
+  it('outputs available servers as JSON', async () => {
+    using output = captureOutput();
+
+    await run(['mcp', 'list', '--json']);
+
+    const parsed = JSON.parse(output.stdout);
+    expect(parsed.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'confidence-flags' }),
+        expect.objectContaining({ name: 'confidence-docs' }),
+      ]),
+    );
+  });
+
+  it('outputs available servers as a table', async () => {
+    using output = captureOutput();
+
+    await run(['mcp', 'list', '--output', 'table']);
+
+    expect(output.stdout).toContain('confidence-flags');
+    expect(output.stdout).toContain('confidence-docs');
+    expect(output.stdout).toContain('Server');
+  });
+});
+
+describe('mcp status', () => {
+  it('outputs server statuses as JSON', async () => {
+    using _auth = prepareAuthTokens('valid');
+    using output = captureOutput();
+
+    await run(['mcp', 'status', '--json']);
+
+    const parsed = JSON.parse(output.stdout);
+    expect(parsed.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ server: 'confidence-flags', status: 'Connected' }),
+        expect.objectContaining({ server: 'confidence-docs', status: 'Connected' }),
+      ]),
+    );
+  });
+});
+
+describe('mcp install', () => {
+  it('connects all MCP servers', async () => {
+    using _auth = prepareAuthTokens('valid');
+    using _output = captureOutput();
+
+    await run(['mcp', 'install']);
+
+    expect(mockIntegration.connectMcpServer).toHaveBeenCalledTimes(2);
+    expect(mockIntegration.connectMcpServer).toHaveBeenCalledWith(
+      expect.objectContaining({ serverName: 'confidence-flags' }),
+    );
+    expect(mockIntegration.connectMcpServer).toHaveBeenCalledWith(
+      expect.objectContaining({ serverName: 'confidence-docs' }),
+    );
+  });
+
+  it('reports failure to stderr when a connection fails', async () => {
+    using _auth = prepareAuthTokens('valid');
+    using output = captureOutput();
+    vi.mocked(mockIntegration.connectMcpServer).mockRejectedValueOnce(
+      new Error('connection refused'),
+    );
+
+    await run(['mcp', 'install']);
+
+    expect(output.stderr).toContain('connection refused');
+  });
+});
+
+describe('mcp uninstall', () => {
+  it('disconnects all MCP servers', async () => {
+    using _auth = prepareAuthTokens('valid');
+    using _output = captureOutput();
+
+    await run(['mcp', 'uninstall']);
+
+    expect(mockIntegration.disconnectMcpServer).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('mcp auth', () => {
+  it('re-authenticates and reconnects all servers', async () => {
+    using _auth = prepareAuthTokens('valid');
+    using _output = captureOutput();
+
+    await run(['mcp', 'auth']);
+
+    expect(mockAuthenticate).toHaveBeenCalled();
+    expect(mockIntegration.connectMcpServer).toHaveBeenCalledTimes(2);
+  });
+});

packages/cli/__tests__/commands/sdk.test.ts

@@ -0,0 +1,202 @@
+import yargs from 'yargs';
+import { sdkCommand } from '@commands/sdk.js';
+import { captureOutput } from '../helpers/capture.js';
+
+const mockCallMcpTool = vi.fn().mockResolvedValue('npm install @spotify-confidence/sdk');
+const mockExecFile = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+const mockDetectFramework = vi.fn();
+const mockDetectPackageManager = vi.fn().mockReturnValue('npm');
+
+vi.mock('@spotify-confidence/core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@spotify-confidence/core')>();
+  return {
+    ...actual,
+    callMcpTool: (...args: unknown[]) => mockCallMcpTool(...args),
+    execFile: (...args: unknown[]) => mockExecFile(...args),
+    detectFramework: (...args: unknown[]) => mockDetectFramework(...args),
+    detectPackageManager: (...args: unknown[]) => mockDetectPackageManager(...args),
+  };
+});
+
+const REACT_FRAMEWORK = {
+  id: 'react',
+  name: 'React',
+  sdkPackage: '@spotify-confidence/sdk',
+  docsUrl: 'https://confidence.spotify.com/docs/sdks/client/javascript',
+};
+
+const PYTHON_FRAMEWORK = {
+  id: 'python',
+  name: 'Python',
+  sdkPackage: 'confidence-openfeature-provider',
+  docsUrl: 'https://confidence.spotify.com/docs/sdks/server/python',
+};
+
+const KOTLIN_FRAMEWORK = {
+  id: 'kotlin',
+  name: 'Android (Kotlin)',
+  sdkPackage: 'com.spotify.confidence:openfeature-provider-android',
+  docsUrl: 'https://confidence.spotify.com/docs/sdks/client/android',
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+function run(args: string[]) {
+  return yargs(args)
+    .option('json', { type: 'boolean', default: false })
+    .option('output', { type: 'string' })
+    .option('project', { type: 'string' })
+    .command(sdkCommand)
+    .parse();
+}
+
+describe('sdk list', () => {
+  it('outputs available SDKs as JSON', async () => {
+    using output = captureOutput();
+
+    await run(['sdk', 'list', '--json']);
+
+    const parsed = JSON.parse(output.stdout);
+    expect(parsed.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ package: '@spotify-confidence/sdk' }),
+        expect.objectContaining({
+          name: 'Python',
+          package: 'confidence-openfeature-provider',
+        }),
+        expect.objectContaining({
+          package: 'github.com/spotify/confidence-resolver/openfeature-provider/go',
+        }),
+      ]),
+    );
+  });
+
+  it('deduplicates SDKs sharing the same package', async () => {
+    using output = captureOutput();
+
+    await run(['sdk', 'list', '--json']);
+
+    const parsed = JSON.parse(output.stdout);
+    const packages = parsed.data.map((s: { package: string }) => s.package);
+    expect(packages).toEqual([...new Set(packages)]);
+  });
+
+  it('outputs available SDKs as a table', async () => {
+    using output = captureOutput();
+
+    await run(['sdk', 'list', '--output', 'table']);
+
+    expect(output.stdout).toContain('SDK');
+    expect(output.stdout).toContain('Package');
+  });
+});
+
+describe('sdk install', () => {
+  it('detects framework and installs SDK via docs lookup', async () => {
+    using _output = captureOutput();
+    mockDetectFramework.mockResolvedValue(REACT_FRAMEWORK);
+    mockCallMcpTool.mockResolvedValue('npm install @spotify-confidence/sdk');
+
+    await run(['sdk', 'install']);
+
+    expect(mockDetectFramework).toHaveBeenCalled();
+    expect(mockCallMcpTool).toHaveBeenCalledWith(
+      'confidence-docs',
+      'searchDocumentation',
+      { query: 'React SDK install command' },
+      expect.objectContaining({}),
+    );
+    expect(mockExecFile).toHaveBeenCalledWith(
+      'npm',
+      ['install', '@spotify-confidence/sdk'],
+      expect.objectContaining({ cwd: expect.any(String) }),
+    );
+  });
+
+  it('uses detected package manager regardless of docs response', async () => {
+    using _output = captureOutput();
+    mockDetectPackageManager.mockReturnValue('pnpm');
+    mockDetectFramework.mockResolvedValue(REACT_FRAMEWORK);
+    mockCallMcpTool.mockResolvedValue('npm install @spotify-confidence/sdk');
+
+    await run(['sdk', 'install']);
+
+    expect(mockExecFile).toHaveBeenCalledWith(
+      'pnpm',
+      ['install', '@spotify-confidence/sdk'],
+      expect.objectContaining({ cwd: expect.any(String) }),
+    );
+  });
+
+  it('falls back to framework sdkPackage when docs are unavailable', async () => {
+    using _output = captureOutput();
+    mockDetectPackageManager.mockReturnValue('pip');
+    mockDetectFramework.mockResolvedValue(PYTHON_FRAMEWORK);
+    mockCallMcpTool.mockRejectedValue(new Error('network error'));
+
+    await run(['sdk', 'install']);
+
+    expect(mockExecFile).toHaveBeenCalledWith(
+      'pip',
+      ['install', 'confidence-openfeature-provider'],
+      expect.objectContaining({ cwd: expect.any(String) }),
+    );
+  });
+
+  it('accepts --sdk to skip detection', async () => {
+    using _output = captureOutput();
+    mockDetectPackageManager.mockReturnValue('go');
+    mockCallMcpTool.mockResolvedValue(
+      'go get github.com/spotify/confidence-resolver/openfeature-provider/go',
+    );
+
+    await run(['sdk', 'install', '--sdk', 'go']);
+
+    expect(mockDetectFramework).not.toHaveBeenCalled();
+    expect(mockExecFile).toHaveBeenCalledWith(
+      'go',
+      ['get', 'github.com/spotify/confidence-resolver/openfeature-provider/go'],
+      expect.objectContaining({ cwd: expect.any(String) }),
+    );
+  });
+
+  it('prints manual instructions for gradle projects', async () => {
+    using output = captureOutput();
+    mockDetectPackageManager.mockReturnValue('gradle');
+    mockDetectFramework.mockResolvedValue(KOTLIN_FRAMEWORK);
+
+    await run(['sdk', 'install']);
+
+    expect(output.stdout).toContain('build.gradle');
+    expect(output.stdout).toContain(KOTLIN_FRAMEWORK.sdkPackage);
+    expect(mockExecFile).not.toHaveBeenCalled();
+  });
+
+  it('reports error for unknown SDK id', async () => {
+    using output = captureOutput();
+
+    await run(['sdk', 'install', '--sdk', 'cobol']);
+
+    expect(output.stderr).toContain('Unknown SDK: cobol');
+  });
+
+  it('reports error when framework cannot be detected', async () => {
+    using output = captureOutput();
+    mockDetectFramework.mockResolvedValue(null);
+
+    await run(['sdk', 'install']);
+
+    expect(output.stderr).toContain('Could not detect project framework');
+  });
+
+  it('reports error when no project is found', async () => {
+    using output = captureOutput();
+    mockDetectPackageManager.mockReturnValue(null);
+
+    await run(['sdk', 'install']);
+
+    expect(output.stderr).toContain('No project found');
+  });
+});

packages/cli/__tests__/features/mcp/resolve-ide.test.ts

@@ -0,0 +1,52 @@
+import { setConfigValue } from '@spotify-confidence/core';
+import { prepareAuthTokens } from '@spotify-confidence/testing/auth';
+
+vi.mock('@inquirer/select', () => ({
+  default: vi.fn(),
+}));
+
+import select from '@inquirer/select';
+
+describe('resolveIde', () => {
+  async function loadResolveIde() {
+    const mod = await import('@features/mcp/resolve-ide.js');
+    return mod.resolveIde;
+  }
+
+  it('returns the saved IDE from config without prompting', async () => {
+    using _config = prepareAuthTokens('none');
+    setConfigValue('ide', 'cursor');
+    const sut = await loadResolveIde();
+
+    const result = await sut();
+
+    expect(result).toBe('cursor');
+    expect(select).not.toHaveBeenCalled();
+  });
+
+  it('prompts when no IDE is saved and returns the selection', async () => {
+    using _config = prepareAuthTokens('none');
+    vi.mocked(select).mockResolvedValueOnce('codex');
+    const sut = await loadResolveIde();
+
+    const result = await sut();
+
+    expect(result).toBe('codex');
+    expect(select).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('AI coding agent'),
+      }),
+    );
+  });
+
+  it('persists the selected IDE to config', async () => {
+    using _config = prepareAuthTokens('none');
+    vi.mocked(select).mockResolvedValueOnce('claude');
+    const sut = await loadResolveIde();
+
+    await sut();
+
+    const { getConfigValue } = await import('@spotify-confidence/core');
+    expect(getConfigValue('ide')).toBe('claude');
+  });
+});