@bonesofspring/ai-rules 0.2.18 → 0.2.19

package/scripts/test-cli-mcp-merge.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * Integration test: `ai-rules init` merges mcpServers (preset keys update, extras kept).
+ */
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const cli = path.join(packageDirectory, 'bin', 'cli.js');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function init(cwd, tool, preset) {
+  return execFileSync(process.execPath, [cli, 'init', tool, '--preset', preset, '--cwd', cwd], {
+    encoding: 'utf8',
+  });
+}
+
+function listBackups(filePath) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  return fs.readdirSync(dir).filter((name) => name.startsWith(`${base}.bak`));
+}
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-merge-'));
+
+try {
+  const cursorMcp = path.join(tmp, '.cursor', 'mcp.json');
+  writeJson(cursorMcp, {
+    mcpServers: {
+      context7: {
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp@old'],
+        env: { CONTEXT7_API_KEY: 'keep-me' },
+      },
+      storybook: { url: 'http://localhost:6006/mcp' },
+    },
+    localOnly: true,
+  });
+
+  const cursorOut = init(tmp, 'cursor', 'next');
+  assert.match(cursorOut, /kept extra servers: storybook/);
+  const cursorMerged = readJson(cursorMcp);
+  assert.equal(cursorMerged.localOnly, true);
+  assert.ok(cursorMerged.mcpServers.storybook);
+  assert.equal(cursorMerged.mcpServers.storybook.url, 'http://localhost:6006/mcp');
+  assert.ok(cursorMerged.mcpServers.context7);
+  assert.deepEqual(cursorMerged.mcpServers.context7.args, ['-y', '@upstash/context7-mcp@4.0.2']);
+  assert.equal(cursorMerged.mcpServers.context7.env.CONTEXT7_API_KEY, 'keep-me');
+  assert.ok(cursorMerged.mcpServers.playwright);
+  assert.ok(cursorMerged.mcpServers.figma);
+  assert.equal(cursorMerged.mcpServers.playwright.args.includes('@playwright/mcp@0.0.79'), true);
+
+  const claudeMcp = path.join(tmp, '.mcp.json');
+  writeJson(claudeMcp, {
+    mcpServers: {
+      'user-storybook': { command: 'npx', args: ['-y', '@storybook/addon-mcp'] },
+    },
+  });
+  const claudeOut = init(tmp, 'claude', 'next');
+  assert.match(claudeOut, /kept extra servers: user-storybook/);
+  const claudeMerged = readJson(claudeMcp);
+  assert.ok(claudeMerged.mcpServers['user-storybook']);
+  assert.ok(claudeMerged.mcpServers.context7);
+
+  const invalidDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-invalid-'));
+  const invalidPath = path.join(invalidDir, '.cursor', 'mcp.json');
+  fs.mkdirSync(path.dirname(invalidPath), { recursive: true });
+  fs.writeFileSync(invalidPath, '{not json');
+  init(invalidDir, 'cursor', 'java');
+  const invalidBackups = listBackups(invalidPath);
+  assert.equal(invalidBackups.length, 1);
+  const replaced = readJson(invalidPath);
+  assert.ok(replaced.mcpServers.context7);
+  assert.equal(replaced.mcpServers.storybook, undefined);
+
+  fs.writeFileSync(invalidPath, '{still not json');
+  init(invalidDir, 'cursor', 'java');
+  assert.equal(listBackups(invalidPath).length, 2);
+  fs.rmSync(invalidDir, { recursive: true, force: true });
+
+  const jsoncDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-jsonc-'));
+  const jsoncPath = path.join(jsoncDir, '.cursor', 'mcp.json');
+  fs.mkdirSync(path.dirname(jsoncPath), { recursive: true });
+  fs.writeFileSync(jsoncPath, '{ "mcpServers": { "storybook": { "url": "http://localhost:6006/mcp" } }, }\n');
+  init(jsoncDir, 'cursor', 'java');
+  assert.equal(listBackups(jsoncPath).length, 1);
+  assert.equal(readJson(jsoncPath).mcpServers.storybook, undefined);
+  fs.rmSync(jsoncDir, { recursive: true, force: true });
+
+  const arrayDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-array-'));
+  const arrayPath = path.join(arrayDir, '.cursor', 'mcp.json');
+  writeJson(arrayPath, { mcpServers: [], localOnly: true });
+  init(arrayDir, 'cursor', 'java');
+  assert.equal(listBackups(arrayPath).length, 1);
+  const arrayMerged = readJson(arrayPath);
+  assert.equal(arrayMerged.localOnly, true);
+  assert.ok(arrayMerged.mcpServers.context7);
+  assert.equal(Array.isArray(arrayMerged.mcpServers), false);
+  fs.rmSync(arrayDir, { recursive: true, force: true });
+
+  const nullDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-null-'));
+  const nullPath = path.join(nullDir, '.cursor', 'mcp.json');
+  writeJson(nullPath, null);
+  init(nullDir, 'cursor', 'java');
+  assert.equal(listBackups(nullPath).length, 1);
+  assert.ok(readJson(nullPath).mcpServers.context7);
+  fs.rmSync(nullDir, { recursive: true, force: true });
+
+  const deletedDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-deleted-'));
+  const deletedPath = path.join(deletedDir, '.cursor', 'mcp.json');
+  writeJson(deletedPath, {
+    mcpServers: {
+      context7: { command: 'npx', args: ['-y', '@upstash/context7-mcp'] },
+    },
+  });
+  init(deletedDir, 'cursor', 'next');
+  const restored = readJson(deletedPath);
+  assert.ok(restored.mcpServers.playwright);
+  fs.rmSync(deletedDir, { recursive: true, force: true });
+
+  console.log('test-cli-mcp-merge: ok');
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}