claude review fixes

KKonstantinov · KKonstantinov · commit 6386627df8d5 · 2026-04-23T21:47:44.000+03:00
diff --git a/packages/codemod/src/cli.ts b/packages/codemod/src/cli.ts
@@ -20,14 +20,14 @@ program.name('mcp-codemod').description('Codemod to migrate MCP TypeScript SDK c
 
 for (const [name, migration] of listMigrations()) {
     program
-        .command(`${name} <target-dir>`)
+        .command(`${name} [target-dir]`)
         .description(migration.description)
         .option('-d, --dry-run', 'Preview changes without writing files')
         .option('-t, --transforms <ids>', 'Comma-separated transform IDs to run (default: all)')
         .option('-v, --verbose', 'Show detailed per-change output')
         .option('--ignore <patterns...>', 'Additional glob patterns to ignore')
         .option('--list', 'List available transforms for this migration')
-        .action((targetDir: string, opts: Record<string, unknown>) => {
+        .action((targetDir: string | undefined, opts: Record<string, unknown>) => {
             try {
                 if (opts['list']) {
                     console.log(`\nAvailable transforms for ${name}:\n`);
@@ -38,6 +38,12 @@ for (const [name, migration] of listMigrations()) {
                     return;
                 }
 
+                if (!targetDir) {
+                    console.error(`\nError: missing required argument <target-dir>.\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+
                 const resolvedDir = path.resolve(targetDir);
 
                 if (!existsSync(resolvedDir) || !statSync(resolvedDir).isDirectory()) {
@@ -98,7 +104,15 @@ for (const [name, migration] of listMigrations()) {
                         console.log(formatDiagnostic(d));
                     }
                     console.log('');
-                    process.exitCode = 1;
+                }
+
+                const infos = result.diagnostics.filter(d => d.level === DiagnosticLevel.Info);
+                if (infos.length > 0) {
+                    console.log(`Info (${infos.length}):`);
+                    for (const d of infos) {
+                        console.log(formatDiagnostic(d));
+                    }
+                    console.log('');
                 }
 
                 if (opts['dryRun']) {
diff --git a/packages/codemod/src/utils/projectAnalyzer.ts b/packages/codemod/src/utils/projectAnalyzer.ts
@@ -3,9 +3,23 @@ import path from 'node:path';
 
 import type { TransformContext } from '../types.js';
 
+const PROJECT_ROOT_MARKERS = ['.git', 'node_modules'];
+
+function findPackageJson(startDir: string): string | undefined {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+    while (true) {
+        const candidate = path.join(dir, 'package.json');
+        if (existsSync(candidate)) return candidate;
+        if (dir === root) return undefined;
+        if (PROJECT_ROOT_MARKERS.some(m => existsSync(path.join(dir, m)))) return undefined;
+        dir = path.dirname(dir);
+    }
+}
+
 export function analyzeProject(targetDir: string): TransformContext {
-    const pkgJsonPath = path.join(targetDir, 'package.json');
-    if (!existsSync(pkgJsonPath)) {
+    const pkgJsonPath = findPackageJson(targetDir);
+    if (!pkgJsonPath) {
         return { projectType: 'unknown' };
     }
 
diff --git a/packages/codemod/test/cli.test.ts b/packages/codemod/test/cli.test.ts
@@ -0,0 +1,83 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, it, expect, afterEach } from 'vitest';
+
+const CLI_PATH = path.resolve(__dirname, '../dist/cli.mjs');
+
+let tempDir: string;
+
+function createTempDir(): string {
+    tempDir = mkdtempSync(path.join(tmpdir(), 'mcp-codemod-cli-'));
+    return tempDir;
+}
+
+function runCli(args: string[]): { stdout: string; stderr: string; exitCode: number } {
+    try {
+        const stdout = execFileSync('node', [CLI_PATH, ...args], {
+            encoding: 'utf8',
+            env: { ...process.env, NODE_NO_WARNINGS: '1' }
+        });
+        return { stdout, stderr: '', exitCode: 0 };
+    } catch (error: unknown) {
+        const e = error as { stdout: string; stderr: string; status: number };
+        return { stdout: e.stdout ?? '', stderr: e.stderr ?? '', exitCode: e.status ?? 1 };
+    }
+}
+
+afterEach(() => {
+    if (tempDir) {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+
+describe('CLI', () => {
+    it('--list works without a target-dir argument', () => {
+        const { stdout, exitCode } = runCli(['v1-to-v2', '--list']);
+        expect(exitCode).toBe(0);
+        expect(stdout).toContain('Available transforms');
+        expect(stdout).toContain('imports');
+    });
+
+    it('errors when target-dir is missing and --list is not set', () => {
+        const { stderr, exitCode } = runCli(['v1-to-v2']);
+        expect(exitCode).toBe(1);
+        expect(stderr).toContain('missing required argument');
+    });
+
+    it('exits 0 when only warnings are present (no errors)', () => {
+        const dir = createTempDir();
+        writeFileSync(
+            path.join(dir, 'server.ts'),
+            [
+                `import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';`,
+                `const transport = new SSEServerTransport();`,
+                ``
+            ].join('\n')
+        );
+
+        const { stdout, exitCode } = runCli(['v1-to-v2', dir]);
+        expect(stdout).toContain('Warning');
+        expect(exitCode).toBe(0);
+    });
+
+    it('prints info diagnostics', () => {
+        const dir = createTempDir();
+        writeFileSync(
+            path.join(dir, 'server.ts'),
+            [
+                `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';`,
+                `const server = new McpServer({ name: 'test', version: '1.0' });`,
+                `server.tool('greet', 'Say hello', { name: z.string() }, async ({ name }) => {`,
+                `    return { content: [{ type: 'text', text: name }] };`,
+                `});`,
+                ``
+            ].join('\n')
+        );
+
+        const { stdout, exitCode } = runCli(['v1-to-v2', dir]);
+        expect(stdout).toContain('Info');
+        expect(exitCode).toBe(0);
+    });
+});
diff --git a/packages/codemod/test/projectAnalyzer.test.ts b/packages/codemod/test/projectAnalyzer.test.ts
@@ -0,0 +1,117 @@
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, it, expect, afterEach } from 'vitest';
+
+import { analyzeProject } from '../src/utils/projectAnalyzer.js';
+
+let tempDir: string;
+
+function createTempDir(): string {
+    tempDir = mkdtempSync(path.join(tmpdir(), 'mcp-codemod-analyzer-'));
+    return tempDir;
+}
+
+afterEach(() => {
+    if (tempDir) {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+
+describe('analyzeProject', () => {
+    it('returns unknown when no package.json exists', () => {
+        const dir = createTempDir();
+        mkdirSync(path.join(dir, '.git'), { recursive: true });
+        mkdirSync(path.join(dir, 'src'), { recursive: true });
+
+        const result = analyzeProject(path.join(dir, 'src'));
+        expect(result.projectType).toBe('unknown');
+    });
+
+    it('finds package.json in parent directory', () => {
+        const dir = createTempDir();
+        mkdirSync(path.join(dir, 'src'), { recursive: true });
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: { '@modelcontextprotocol/client': '^2.0.0' }
+            })
+        );
+
+        const result = analyzeProject(path.join(dir, 'src'));
+        expect(result.projectType).toBe('client');
+    });
+
+    it('finds package.json multiple levels up', () => {
+        const dir = createTempDir();
+        mkdirSync(path.join(dir, 'src', 'lib', 'utils'), { recursive: true });
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: { '@modelcontextprotocol/server': '^2.0.0' }
+            })
+        );
+
+        const result = analyzeProject(path.join(dir, 'src', 'lib', 'utils'));
+        expect(result.projectType).toBe('server');
+    });
+
+    it('stops walking at .git boundary', () => {
+        const dir = createTempDir();
+        mkdirSync(path.join(dir, 'project', 'src'), { recursive: true });
+        mkdirSync(path.join(dir, 'project', '.git'), { recursive: true });
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: { '@modelcontextprotocol/client': '^2.0.0' }
+            })
+        );
+
+        const result = analyzeProject(path.join(dir, 'project', 'src'));
+        expect(result.projectType).toBe('unknown');
+    });
+
+    it('stops walking at node_modules boundary', () => {
+        const dir = createTempDir();
+        mkdirSync(path.join(dir, 'project', 'src'), { recursive: true });
+        mkdirSync(path.join(dir, 'project', 'node_modules'), { recursive: true });
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: { '@modelcontextprotocol/client': '^2.0.0' }
+            })
+        );
+
+        const result = analyzeProject(path.join(dir, 'project', 'src'));
+        expect(result.projectType).toBe('unknown');
+    });
+
+    it('detects both client and server dependencies', () => {
+        const dir = createTempDir();
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: {
+                    '@modelcontextprotocol/client': '^2.0.0',
+                    '@modelcontextprotocol/server': '^2.0.0'
+                }
+            })
+        );
+
+        const result = analyzeProject(dir);
+        expect(result.projectType).toBe('both');
+    });
+
+    it('finds package.json at targetDir itself', () => {
+        const dir = createTempDir();
+        writeFileSync(
+            path.join(dir, 'package.json'),
+            JSON.stringify({
+                dependencies: { '@modelcontextprotocol/server': '^2.0.0' }
+            })
+        );
+
+        const result = analyzeProject(dir);
+        expect(result.projectType).toBe('server');
+    });
+});
