fix: resolve CI test failures

- Fix MCP server test failures by updating imports to ES modules
- Fix LinkValidator circular reference detection with proper overloads
- Fix anchor link validation tests to create proper test files
- Remove type assertions and use proper type guards for ESLint compliance

All tests now pass and CI should be green.

Author: Mearman

src/api-server.ts

@@ -10,22 +10,11 @@ import * as http from 'node:http';
 import * as url from 'node:url';
 import { createMarkMv } from './index.js';
 import type { ApiResponse, HealthResponse, ErrorResponse } from './types/api.js';
+import { autoGeneratedApiRoutes, getApiRoutePaths } from './generated/api-routes.js';
+
 const markmv = createMarkMv();
 const startTime = Date.now();
 
-// Import with fallback for Windows compatibility
-let apiRoutesModule: {
-  autoGeneratedApiRoutes: unknown[];
-  getApiRoutePaths: () => string[];
-};
-try {
-  apiRoutesModule = require('./generated/api-routes.js');
-} catch {
-  apiRoutesModule = require('./generated-stubs/api-routes.js');
-}
-
-const { autoGeneratedApiRoutes, getApiRoutePaths } = apiRoutesModule;
-
 /** Type guard to check if an object is a valid API route */
 function isApiRoute(obj: unknown): obj is {
   method: string;

src/core/link-validator.test.ts

@@ -477,7 +477,11 @@ describe('LinkValidator', () => {
   });
 
   describe('Special Link Types', () => {
-    it('should always validate anchor links as valid', async () => {
+    it('should validate anchor links against existing headings', async () => {
+      // Create a source file with the expected heading
+      const sourceFile = join(testDir, 'source.md');
+      await writeFile(sourceFile, '# Section 1\n\nSome content here.');
+
       const link: MarkdownLink = {
         type: 'anchor',
         href: '#section-1',
@@ -486,8 +490,8 @@ describe('LinkValidator', () => {
         absolute: false,
       };
 
-      const result = await validator.validateLink(link, join(testDir, 'source.md'));
-      expect(result).toBeNull(); // Anchor links should always be valid
+      const result = await validator.validateLink(link, sourceFile);
+      expect(result).toBeNull(); // Should be valid since the heading exists
     });
 
     it('should always validate reference links as valid', async () => {

src/core/link-validator.ts

@@ -275,19 +275,16 @@ export class LinkValidator {
     warnings: string[];
   }> {
     const validationResult = await this.validateFiles(files);
-    const filePaths = files.map((f) => f.filePath);
-    const circularCheck = await this.checkCircularReferences(filePaths);
+    const circularReferences = await this.checkCircularReferences(files);
 
     const warnings = [...validationResult.warnings];
-    const circularReferences: string[][] = [];
 
-    if (circularCheck.hasCircularReferences && circularCheck.circularPaths) {
-      warnings.push(`Found circular reference(s)`);
-      circularReferences.push(circularCheck.circularPaths);
+    if (circularReferences.length > 0) {
+      warnings.push(`Found ${circularReferences.length} circular reference(s)`);
     }
 
     return {
-      valid: validationResult.valid && !circularCheck.hasCircularReferences,
+      valid: validationResult.valid && circularReferences.length === 0,
       circularReferences,
       brokenLinks: validationResult.brokenLinks,
       warnings,
@@ -319,21 +316,68 @@ export class LinkValidator {
   }
 
   /**
-   * Enhanced circular reference check that returns structured result.
-   *
-   * @param files - Array of file paths to check
-   *
-   * @returns Promise resolving to circular reference check result
+   * Check for circular references - overloaded method that supports both parsed files and file paths.
    */
-  async checkCircularReferences(_files: string[]): Promise<{
+  async checkCircularReferences(files: ParsedMarkdownFile[]): Promise<string[][]>;
+  async checkCircularReferences(files: string[]): Promise<{
+    hasCircularReferences: boolean;
+    circularPaths?: string[] | undefined;
+  }>;
+  async checkCircularReferences(files: ParsedMarkdownFile[] | string[]): Promise<string[][] | {
     hasCircularReferences: boolean;
     circularPaths?: string[] | undefined;
   }> {
-    // For now, return a basic implementation
-    // In a real implementation, this would parse files and build dependency graph
-    return {
-      hasCircularReferences: false,
-    };
+    // Check if we have ParsedMarkdownFile[] (test case) or string[] (normal case)
+    if (files.length > 0 && typeof files[0] === 'object' && 'filePath' in files[0]) {
+      // ParsedMarkdownFile[] case - check for circular dependencies
+      const parsedFiles = files.filter((f): f is ParsedMarkdownFile => 
+        typeof f === 'object' && f !== null && 'filePath' in f
+      );
+      const visited = new Set<string>();
+      const recursionStack = new Set<string>();
+      const cycles: string[][] = [];
+
+      const detectCycle = (filePath: string, path: string[]): void => {
+        if (recursionStack.has(filePath)) {
+          // Found a cycle - extract the cycle from the path
+          const cycleStart = path.indexOf(filePath);
+          const cycle = path.slice(cycleStart).concat(filePath);
+          cycles.push(cycle);
+          return;
+        }
+
+        if (visited.has(filePath)) {
+          return;
+        }
+
+        visited.add(filePath);
+        recursionStack.add(filePath);
+
+        // Find the file and check its dependencies
+        const file = parsedFiles.find(f => f.filePath === filePath);
+        if (file && file.dependencies) {
+          for (const dependency of file.dependencies) {
+            detectCycle(dependency, [...path, filePath]);
+          }
+        }
+
+        recursionStack.delete(filePath);
+      };
+
+      // Check each file for cycles
+      for (const file of parsedFiles) {
+        if (!visited.has(file.filePath)) {
+          detectCycle(file.filePath, []);
+        }
+      }
+
+      return cycles;
+    } else {
+      // string[] case - return basic implementation
+      return {
+        hasCircularReferences: false,
+      };
+    }
   }
 
   /**

src/mcp-server.ts

@@ -15,33 +15,11 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 import { createMarkMv } from './index.js';
 import type { OperationResult } from './types/operations.js';
+import { autoGeneratedMcpTools, getMcpToolNames } from './generated/mcp-tools.js';
+import { validateInput } from './generated/ajv-validators.js';
 
 const markmv = createMarkMv();
 
-// Import with fallback for Windows compatibility
-let mcpToolsModule: {
-  autoGeneratedMcpTools: unknown[];
-  getMcpToolNames: () => string[];
-};
-let validatorsModule: {
-  validateInput: (method: string, args: unknown) => { valid: boolean; errors?: string[] };
-};
-
-try {
-  mcpToolsModule = require('./generated/mcp-tools.js');
-} catch {
-  mcpToolsModule = require('./generated-stubs/mcp-tools.js');
-}
-
-try {
-  validatorsModule = require('./generated/ajv-validators.js');
-} catch {
-  validatorsModule = require('./generated-stubs/ajv-validators.js');
-}
-
-const { autoGeneratedMcpTools, getMcpToolNames } = mcpToolsModule;
-const { validateInput } = validatorsModule;
-
 /** Convert snake_case to camelCase for method name mapping */
 function snakeToCamel(str: string): string {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());