claude review fixes

Author: KKonstantinov

packages/codemod/src/migrations/v1-to-v2/transforms/expressMiddleware.ts

@@ -0,0 +1,55 @@
+import type { SourceFile } from 'ts-morph';
+import { Node, SyntaxKind } from 'ts-morph';
+
+import type { Diagnostic, Transform, TransformContext, TransformResult } from '../../../types.js';
+import { info } from '../../../utils/diagnostics.js';
+
+export const expressMiddlewareTransform: Transform = {
+    name: 'Express middleware signature migration',
+    id: 'express-middleware',
+    apply(sourceFile: SourceFile, _context: TransformContext): TransformResult {
+        const diagnostics: Diagnostic[] = [];
+        let changesCount = 0;
+
+        changesCount += rewriteHostHeaderValidation(sourceFile, diagnostics);
+
+        return { changesCount, diagnostics };
+    }
+};
+
+function rewriteHostHeaderValidation(sourceFile: SourceFile, diagnostics: Diagnostic[]): number {
+    let changesCount = 0;
+
+    const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    for (const call of calls) {
+        const expr = call.getExpression();
+        if (!Node.isIdentifier(expr) || expr.getText() !== 'hostHeaderValidation') continue;
+
+        const args = call.getArguments();
+        if (args.length !== 1) continue;
+
+        const firstArg = args[0]!;
+        if (!Node.isObjectLiteralExpression(firstArg)) continue;
+
+        const allowedHostsProp = firstArg.getProperty('allowedHosts');
+        if (!allowedHostsProp || !Node.isPropertyAssignment(allowedHostsProp)) continue;
+
+        const initializer = allowedHostsProp.getInitializer();
+        if (!initializer) continue;
+
+        const arrayText = initializer.getText();
+        firstArg.replaceWithText(arrayText);
+        changesCount++;
+
+        diagnostics.push(
+            info(
+                sourceFile.getFilePath(),
+                call.getStartLineNumber(),
+                'hostHeaderValidation({ allowedHosts: [...] }) simplified to hostHeaderValidation([...]). Verify the migration.'
+            )
+        );
+    }
+
+    return changesCount;
+}

packages/codemod/src/migrations/v1-to-v2/transforms/importPaths.ts

@@ -1,6 +1,7 @@
 import type { SourceFile } from 'ts-morph';
 
 import type { Transform, TransformContext, TransformResult } from '../../../types.js';
+import { renameAllReferences } from '../../../utils/astUtils.js';
 import { warning } from '../../../utils/diagnostics.js';
 import { addOrMergeImport, getSdkExports, getSdkImports, isTypeOnlyImport } from '../../../utils/importUtils.js';
 import { resolveTypesPackage } from '../../../utils/projectAnalyzer.js';
@@ -53,9 +54,11 @@ export const importPathsTransform: Transform = {
 
         for (const imp of sdkImports) {
             const specifier = imp.getModuleSpecifierValue();
-            const namedImports = imp.getNamedImports().map(n => n.getName());
+            const namedImports = imp.getNamedImports();
             const typeOnly = isTypeOnlyImport(imp);
             const line = imp.getStartLineNumber();
+            const defaultImport = imp.getDefaultImport();
+            const namespaceImport = imp.getNamespaceImport();
 
             let mapping = IMPORT_MAP[specifier];
 
@@ -84,9 +87,31 @@ export const importPathsTransform: Transform = {
                 targetPackage = resolveTypesPackage(context, hasClientImport, hasServerImport);
             }
 
-            let resolvedNames = namedImports;
             if (mapping.renamedSymbols) {
-                resolvedNames = namedImports.map(name => mapping.renamedSymbols?.[name] ?? name);
+                for (const [oldName, newName] of Object.entries(mapping.renamedSymbols)) {
+                    renameAllReferences(sourceFile, oldName, newName);
+                }
+            }
+
+            const hasAlias = namedImports.some(n => n.getAliasNode() !== undefined);
+            if (defaultImport || namespaceImport || hasAlias) {
+                imp.setModuleSpecifier(targetPackage);
+                if (mapping.renamedSymbols) {
+                    for (const n of namedImports) {
+                        const newName = mapping.renamedSymbols[n.getName()];
+                        if (newName) {
+                            n.setName(newName);
+                        }
+                    }
+                }
+                changesCount++;
+                continue;
+            }
+
+            const names = namedImports.map(n => n.getName());
+            let resolvedNames = names;
+            if (mapping.renamedSymbols) {
+                resolvedNames = names.map(name => mapping.renamedSymbols?.[name] ?? name);
             }
 
             addPending(targetPackage, resolvedNames, typeOnly);

packages/codemod/src/migrations/v1-to-v2/transforms/index.ts

@@ -1,9 +1,11 @@
 import type { Transform } from '../../../types.js';
 import { contextTypesTransform } from './contextTypes.js';
+import { expressMiddlewareTransform } from './expressMiddleware.js';
 import { handlerRegistrationTransform } from './handlerRegistration.js';
 import { importPathsTransform } from './importPaths.js';
 import { mcpServerApiTransform } from './mcpServerApi.js';
 import { mockPathsTransform } from './mockPaths.js';
+import { removedApisTransform } from './removedApis.js';
 import { schemaParamRemovalTransform } from './schemaParamRemoval.js';
 import { symbolRenamesTransform } from './symbolRenames.js';
 
@@ -14,23 +16,30 @@ import { symbolRenamesTransform } from './symbolRenames.js';
 //    transforms depend on the rewritten import declarations.
 //
 // 2. symbolRenames runs early: renames imported symbols (e.g., McpError →
-//    ProtocolError) that later transforms may reference.
+//    ProtocolError) and rewrites type references (e.g., SchemaInput<T> →
+//    StandardSchemaWithJSON.InferInput<T>).
 //
-// 3. mcpServerApi SHOULD run before contextTypes: it rewrites .tool() etc.
+// 3. removedApis runs after symbolRenames: handles removed Zod helpers,
+//    IsomorphicHeaders, and StreamableHTTPError. Conceptually different
+//    from renames — these are removals with diagnostic guidance.
+//
+// 4. mcpServerApi SHOULD run before contextTypes: it rewrites .tool() etc.
 //    to .registerTool() etc. contextTypes handles both old and new names,
 //    but running mcpServerApi first ensures consistent argument structure.
 //
-// 4. handlerRegistration and schemaParamRemoval are independent of each
-//    other but both depend on importPaths having run.
+// 5. handlerRegistration, schemaParamRemoval, and expressMiddleware are
+//    independent of each other but all depend on importPaths having run.
 //
-// 5. mockPaths runs last: handles test mocks and dynamic imports,
+// 6. mockPaths runs last: handles test mocks and dynamic imports,
 //    independent of the other transforms.
 export const v1ToV2Transforms: Transform[] = [
     importPathsTransform,
     symbolRenamesTransform,
+    removedApisTransform,
     mcpServerApiTransform,
     handlerRegistrationTransform,
     schemaParamRemovalTransform,
+    expressMiddlewareTransform,
     contextTypesTransform,
     mockPathsTransform
 ];

packages/codemod/src/migrations/v1-to-v2/transforms/mockPaths.ts

@@ -173,7 +173,11 @@ function rewriteDynamicImports(sourceFile: SourceFile, context: TransformContext
                             const bindingName = element.getName();
                             const newName = resolved.renamedSymbols[bindingName];
                             if (newName) {
-                                element.getNameNode().replaceWithText(newName);
+                                if (element.getPropertyNameNode()) {
+                                    element.getPropertyNameNode()!.replaceWithText(newName);
+                                } else {
+                                    element.replaceWithText(`${newName}: ${bindingName}`);
+                                }
                                 changes++;
                             }
                         }

packages/codemod/src/migrations/v1-to-v2/transforms/removedApis.ts

@@ -0,0 +1,186 @@
+import type { SourceFile } from 'ts-morph';
+import { Node, SyntaxKind } from 'ts-morph';
+
+import type { Diagnostic, Transform, TransformContext, TransformResult } from '../../../types.js';
+import { renameAllReferences } from '../../../utils/astUtils.js';
+import { warning } from '../../../utils/diagnostics.js';
+import { addOrMergeImport, isAnyMcpSpecifier } from '../../../utils/importUtils.js';
+
+const REMOVED_ZOD_HELPERS: Record<string, string> = {
+    schemaToJson:
+        "Removed in v2. Use `fromJsonSchema()` from @modelcontextprotocol/server for JSON Schema, or your schema library's native conversion.",
+    parseSchemaAsync: "Removed in v2. Use your schema library's validation directly (e.g., Zod's `.safeParseAsync()`).",
+    getSchemaShape: "Removed in v2. These Zod-specific introspection helpers have no v2 equivalent. Use your schema library's native API.",
+    getSchemaDescription:
+        "Removed in v2. These Zod-specific introspection helpers have no v2 equivalent. Use your schema library's native API.",
+    isOptionalSchema:
+        "Removed in v2. These Zod-specific introspection helpers have no v2 equivalent. Use your schema library's native API.",
+    unwrapOptionalSchema:
+        "Removed in v2. These Zod-specific introspection helpers have no v2 equivalent. Use your schema library's native API."
+};
+
+export const removedApisTransform: Transform = {
+    name: 'Removed API handling',
+    id: 'removed-apis',
+    apply(sourceFile: SourceFile, _context: TransformContext): TransformResult {
+        const diagnostics: Diagnostic[] = [];
+        let changesCount = 0;
+
+        changesCount += handleRemovedZodHelpers(sourceFile, diagnostics);
+        changesCount += handleIsomorphicHeaders(sourceFile, diagnostics);
+        changesCount += handleStreamableHTTPError(sourceFile, diagnostics);
+
+        return { changesCount, diagnostics };
+    }
+};
+
+function handleRemovedZodHelpers(sourceFile: SourceFile, diagnostics: Diagnostic[]): number {
+    interface Removal {
+        importName: string;
+        message: string;
+        line: number;
+    }
+
+    const removals: Removal[] = [];
+
+    for (const imp of sourceFile.getImportDeclarations()) {
+        if (!isAnyMcpSpecifier(imp.getModuleSpecifierValue())) continue;
+        const line = imp.getStartLineNumber();
+        for (const namedImport of imp.getNamedImports()) {
+            const name = namedImport.getName();
+            const message = REMOVED_ZOD_HELPERS[name];
+            if (message) {
+                removals.push({ importName: name, message, line });
+            }
+        }
+    }
+
+    for (const removal of removals) {
+        for (const imp of sourceFile.getImportDeclarations()) {
+            for (const namedImport of imp.getNamedImports()) {
+                if (namedImport.getName() === removal.importName) {
+                    namedImport.remove();
+                    if (imp.getNamedImports().length === 0 && !imp.getDefaultImport() && !imp.getNamespaceImport()) {
+                        imp.remove();
+                    }
+                    break;
+                }
+            }
+        }
+        diagnostics.push(warning(sourceFile.getFilePath(), removal.line, `${removal.importName}: ${removal.message}`));
+    }
+
+    return removals.length;
+}
+
+function handleIsomorphicHeaders(sourceFile: SourceFile, diagnostics: Diagnostic[]): number {
+    let changesCount = 0;
+    let foundImport: ReturnType<ReturnType<SourceFile['getImportDeclarations']>[0]['getNamedImports']>[0] | undefined;
+    let foundImportDecl: ReturnType<SourceFile['getImportDeclarations']>[0] | undefined;
+
+    for (const imp of sourceFile.getImportDeclarations()) {
+        if (!isAnyMcpSpecifier(imp.getModuleSpecifierValue())) continue;
+        for (const namedImport of imp.getNamedImports()) {
+            if (namedImport.getName() === 'IsomorphicHeaders') {
+                foundImport = namedImport;
+                foundImportDecl = imp;
+                break;
+            }
+        }
+        if (foundImport) break;
+    }
+
+    if (!foundImport || !foundImportDecl) return 0;
+
+    const line = foundImportDecl.getStartLineNumber();
+
+    renameAllReferences(sourceFile, 'IsomorphicHeaders', 'Headers');
+    changesCount++;
+
+    foundImport.remove();
+    if (foundImportDecl.getNamedImports().length === 0 && !foundImportDecl.getDefaultImport() && !foundImportDecl.getNamespaceImport()) {
+        foundImportDecl.remove();
+    }
+    changesCount++;
+
+    diagnostics.push(
+        warning(
+            sourceFile.getFilePath(),
+            line,
+            'IsomorphicHeaders replaced with standard Web Headers API. Note: Headers uses .get()/.set() methods, not bracket access.'
+        )
+    );
+
+    return changesCount;
+}
+
+function handleStreamableHTTPError(sourceFile: SourceFile, diagnostics: Diagnostic[]): number {
+    let changesCount = 0;
+    let foundImport: ReturnType<ReturnType<SourceFile['getImportDeclarations']>[0]['getNamedImports']>[0] | undefined;
+    let foundImportDecl: ReturnType<SourceFile['getImportDeclarations']>[0] | undefined;
+
+    for (const imp of sourceFile.getImportDeclarations()) {
+        if (!isAnyMcpSpecifier(imp.getModuleSpecifierValue())) continue;
+        for (const namedImport of imp.getNamedImports()) {
+            if (namedImport.getName() === 'StreamableHTTPError') {
+                foundImport = namedImport;
+                foundImportDecl = imp;
+                break;
+            }
+        }
+        if (foundImport) break;
+    }
+
+    if (!foundImport || !foundImportDecl) return 0;
+
+    const line = foundImportDecl.getStartLineNumber();
+    const moduleSpec = foundImportDecl.getModuleSpecifierValue();
+
+    for (const node of sourceFile.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+        const expr = node.getExpression();
+        if (!Node.isIdentifier(expr) || expr.getText() !== 'StreamableHTTPError') continue;
+        diagnostics.push(
+            warning(
+                sourceFile.getFilePath(),
+                node.getStartLineNumber(),
+                'new StreamableHTTPError(statusCode, statusText, body?) → new SdkError(code, message, data?). ' +
+                    'Constructor arguments differ — manual review required. Map HTTP status to SdkErrorCode enum value.'
+            )
+        );
+    }
+
+    renameAllReferences(sourceFile, 'StreamableHTTPError', 'SdkError');
+    changesCount++;
+
+    foundImport.remove();
+    if (foundImportDecl.getNamedImports().length === 0 && !foundImportDecl.getDefaultImport() && !foundImportDecl.getNamespaceImport()) {
+        foundImportDecl.remove();
+    }
+
+    const targetModule = resolveTargetModule(sourceFile, moduleSpec);
+    const insertIndex = sourceFile.getImportDeclarations().length;
+    addOrMergeImport(sourceFile, targetModule, ['SdkError', 'SdkErrorCode'], false, insertIndex);
+    changesCount++;
+
+    diagnostics.push(
+        warning(
+            sourceFile.getFilePath(),
+            line,
+            'StreamableHTTPError replaced with SdkError. Constructor arguments differ — manual review required. ' +
+                'HTTP status is now in error.data?.status.'
+        )
+    );
+
+    return changesCount;
+}
+
+function resolveTargetModule(sourceFile: SourceFile, originalModule: string): string {
+    const imp = sourceFile.getImportDeclarations().find(i => {
+        const spec = i.getModuleSpecifierValue();
+        return spec === '@modelcontextprotocol/client' || spec === '@modelcontextprotocol/server';
+    });
+    if (imp) return imp.getModuleSpecifierValue();
+
+    if (originalModule.includes('/client')) return '@modelcontextprotocol/client';
+    return '@modelcontextprotocol/server';
+}