@boyingliu01/xp-gate 0.12.10 → 0.12.12

package/principles/__tests__/baseline.test.ts

@@ -19,7 +19,7 @@ describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () =>
         lastAnalyzed: new Date().toISOString(),
       },
     };
-    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+    expect(() => storage.validate(entry as unknown as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
   });
 
   it('accepts golangci field in BaselineEntry', () => {
@@ -31,7 +31,7 @@ describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () =>
         lastAnalyzed: new Date().toISOString(),
       },
     };
-    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+    expect(() => storage.validate(entry as unknown as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
   });
 
   it('accepts shellcheck field in BaselineEntry', () => {
@@ -43,7 +43,7 @@ describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () =>
         lastAnalyzed: new Date().toISOString(),
       },
     };
-    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+    expect(() => storage.validate(entry as unknown as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
   });
 
   it('rejects ruff entry with non-numeric warnings', () => {
@@ -55,7 +55,7 @@ describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () =>
         lastAnalyzed: new Date().toISOString(),
       },
     };
-    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).toThrow(/Invalid ruff properties/);
+    expect(() => storage.validate(entry as unknown as Record<string, import('../baseline').BaselineEntry>)).toThrow(/Invalid ruff properties/);
   });
 
   it('combines all lint tools in getSummaryStatistics', () => {
@@ -82,12 +82,13 @@ describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () =>
 
     expect(stats.totalFiles).toBe(3);
     expect(stats.totalWarnings).toBe(10);
-    expect(stats.ruff?.totalWarnings).toBe(5);
-    expect(stats.ruff?.totalErrors).toBe(2);
-    expect(stats.golangci?.totalWarnings).toBe(3);
-    expect(stats.golangci?.totalErrors).toBe(1);
-    expect(stats.shellcheck?.totalWarnings).toBe(2);
-    expect(stats.shellcheck?.totalErrors).toBe(0);
+    const richStats = stats as typeof stats & { ruff: { totalWarnings: number; totalErrors: number }; golangci: { totalWarnings: number; totalErrors: number }; shellcheck: { totalWarnings: number; totalErrors: number } };
+    expect(richStats.ruff.totalWarnings).toBe(5);
+    expect(richStats.ruff.totalErrors).toBe(2);
+    expect(richStats.golangci.totalWarnings).toBe(3);
+    expect(richStats.golangci.totalErrors).toBe(1);
+    expect(richStats.shellcheck.totalWarnings).toBe(2);
+    expect(richStats.shellcheck.totalErrors).toBe(0);
   });
 });
 
@@ -121,11 +122,12 @@ describe('BaselineStorage - extended coverage', () => {
         },
       };
 
-      const stats = storage.getSummaryStatistics(baseline);
+      const rawStats = storage.getSummaryStatistics(baseline);
+      const stats = rawStats as { totalFiles: number; totalWarnings: number; averageWarningsPerFile: number; ccn: { totalWarnings: number; totalMax: number } };
 
       expect(stats.totalFiles).toBe(2);
-      expect(stats.ccn?.totalWarnings).toBe(8);
-      expect(stats.ccn?.totalMax).toBe(30);
+      expect(stats.ccn.totalWarnings).toBe(8);
+      expect(stats.ccn.totalMax).toBe(30);
     });
 
     it('returns averageWarningsPerFile of 0 for empty baseline', () => {
@@ -135,7 +137,7 @@ describe('BaselineStorage - extended coverage', () => {
       expect(stats.totalFiles).toBe(0);
       expect(stats.totalWarnings).toBe(0);
       expect(stats.averageWarningsPerFile).toBe(0);
-      expect(stats.ccn).toBeUndefined();
+      expect('ccn' in stats ? (stats as Record<string, unknown>).ccn : undefined).toBeUndefined();
     });
   });
 

package/principles/__tests__/types.test.ts

@@ -90,6 +90,7 @@ describe('types.ts - Core Interfaces', () => {
         parseAST: () => null,
         extractFunctions: () => [],
         extractClasses: () => [],
+        extractExports: () => [],
         countLines: () => 0,
       };
 

package/principles/adapters/__tests__/base.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';;
 import type { Adapter } from '../../types';
 import { BaseAdapter } from '../base';
 
@@ -24,7 +24,7 @@ import { readFileSync } from 'fs';
 describe('BaseAdapter - Default Implementation', () => {
 
   it('should implement the Adapter interface', () => {
-    (readFileSync as vi.Mock).mockReturnValue('mock file content\ntest line 2');
+    (readFileSync as Mock).mockReturnValue('mock file content\ntest line 2');
     const adapter = new MockAdapter('./test.ts');
     const implemented: Adapter = adapter as unknown as Adapter;
     
@@ -37,7 +37,7 @@ describe('BaseAdapter - Default Implementation', () => {
   });
 
   it('should detect language based on file extension', () => {
-    (readFileSync as vi.Mock).mockReturnValue('file content');
+    (readFileSync as Mock).mockReturnValue('file content');
     
     const adapterTs = new MockAdapter('./test.ts');
     expect(adapterTs.detectLanguage()).toBe('typescript');
@@ -56,35 +56,35 @@ describe('BaseAdapter - Default Implementation', () => {
   });
 
   it('should parse file AST correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('mock file content\ntest line 2');
+    (readFileSync as Mock).mockReturnValue('mock file content\ntest line 2');
     const adapter = new MockAdapter('./test.ts');
     const ast = adapter.parseAST();
     expect(ast).toEqual({ content: 'mock file content\ntest line 2', astType: 'mock' });
   });
 
   it('should extract functions from AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('');
+    (readFileSync as Mock).mockReturnValue('');
     const adapter = new MockAdapter('./test.ts');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
   });
 
   it('should extract classes from AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('');
+    (readFileSync as Mock).mockReturnValue('');
     const adapter = new MockAdapter('./test.ts');
     const classes = adapter.extractClasses();
     expect(Array.isArray(classes)).toBe(true);
   });
 
   it('should count physical lines correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('line 1\nline 2\nline 3');
+    (readFileSync as Mock).mockReturnValue('line 1\nline 2\nline 3');
     const adapter = new MockAdapter('./test.ts');
     const lineCount = adapter.countLines();
     expect(lineCount).toBe(3);
   });
 
   it('should throw error for unsupported file operations', () => {
-    (readFileSync as vi.Mock).mockImplementation(() => {
+    (readFileSync as Mock).mockImplementation(() => {
       throw new Error('Could not read file');
     });
     

package/principles/adapters/__tests__/cpp.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';;
 import { CppAdapter } from '../cpp';
 
 type MockFunction = Record<string, unknown>;
@@ -13,7 +13,7 @@ import { readFileSync } from 'fs';
 describe('CppAdapter', () => {
   
   it('should implement the Adapter interface', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.cpp');
     
     expect(adapter).toHaveProperty('detectLanguage');
@@ -24,59 +24,59 @@ describe('CppAdapter', () => {
   });
 
   it('should detect language as cpp for .cpp files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.cpp');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should detect language as cpp for .cxx files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.cxx');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should detect language as cpp for .cc files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.cc');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should detect language as cpp for .c files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.c');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should detect language as cpp for .hpp files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('#pragma once');
+    (readFileSync as Mock).mockReturnValue('#pragma once');
     const adapter = new CppAdapter('test.hpp');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should detect language as cpp for .h files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('#pragma once');
+    (readFileSync as Mock).mockReturnValue('#pragma once');
     const adapter = new CppAdapter('test.h');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('cpp');
   });
 
   it('should parse C++ file AST correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    (readFileSync as Mock).mockReturnValue('int main() { return 0; }');
     const adapter = new CppAdapter('test.cpp');
     const ast = adapter.parseAST();
     expect(ast).toHaveProperty('content');
     expect(ast).toHaveProperty('language');
     expect(ast).toHaveProperty('filePath');
-    expect(ast.language).toBe('cpp');
+    expect((ast as { language: unknown }).language).toBe('cpp');
   });
 
   it('should extract functions from C++ code', () => {
-    (readFileSync as vi.Mock).mockReturnValue(`
+    (readFileSync as Mock).mockReturnValue(`
 int add(int a, int b) {
   return a + b;
 }
@@ -92,7 +92,7 @@ int main() {
   });
 
   it('should handle C++ strings with special characters', () => {
-    (readFileSync as vi.Mock).mockReturnValue(`
+    (readFileSync as Mock).mockReturnValue(`
 int main() {
   const char* str = "Hello \\"World\\"";
   char c = '\\'';
@@ -107,7 +107,7 @@ int main() {
   });
   
   it('should throw error when file cannot be read', () => {
-    (readFileSync as vi.Mock).mockImplementation(() => {
+    (readFileSync as Mock).mockImplementation(() => {
       throw new Error('Could not read file');
     });
     
@@ -125,7 +125,7 @@ int main() {
 describe('CppAdapter - extractCodeBlock edge cases', () => {
   it('should skip single-line block comment before the opening brace', () => {
     const src = `int foo() /* inline comment */ { return 1; }`;
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block).toContain('{ return 1; }');
@@ -142,7 +142,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  return 42;',
       '}',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block).toContain('return 42;');
@@ -151,7 +151,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
 
   it('should ignore braces inside block comments', () => {
     const src = `int foo() /* fake { brace } here */ { return 7; }`;
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block).toContain('return 7;');
@@ -160,7 +160,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
 
   it('should count nested braces correctly via braceCount++ path', () => {
     const src = `void foo() { if (x) { return; } }`;
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block).toBe('void foo() { if (x) { return; } }');
@@ -168,7 +168,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
 
   it('should handle deeply nested braces (triple nesting)', () => {
     const src = `int bar() { if (a) { while (b) { c++; } } return 0; }`;
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block.trim().endsWith('}')).toBe(true);
@@ -190,7 +190,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  return 0;',
       '}',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block.trim().endsWith('}')).toBe(true);
@@ -205,7 +205,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  return 5;',
       '}',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const block = adapter.extractCodeBlock(0);
     expect(block).toContain('return 5;');
@@ -223,7 +223,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  int value_;',
       '};',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
@@ -240,7 +240,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  int x;',
       '};',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const classes = adapter.extractClasses();
     expect(Array.isArray(classes)).toBe(true);
@@ -250,13 +250,13 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
   });
 
   it('should count lines correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('line1\nline2\nline3');
+    (readFileSync as Mock).mockReturnValue('line1\nline2\nline3');
     const adapter = new CppAdapter('test.cpp');
     expect(adapter.countLines()).toBe(3);
   });
 
   it('should fall back to super.detectLanguage for non-cpp extensions', () => {
-    (readFileSync as vi.Mock).mockReturnValue('content');
+    (readFileSync as Mock).mockReturnValue('content');
     const adapter = new CppAdapter('test.txt');
     expect(adapter.detectLanguage()).toBe('unknown');
   });
@@ -272,7 +272,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
       '  return -x;',
       '}',
     ].join('\n');
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
@@ -281,7 +281,7 @@ describe('CppAdapter - extractCodeBlock edge cases', () => {
 
   it('should extract functions with scope prefix (e.g. MyClass::method)', () => {
     const src = 'void MyClass::method() { return; }';
-    (readFileSync as vi.Mock).mockReturnValue(src);
+    (readFileSync as Mock).mockReturnValue(src);
     const adapter = new CppAdapter('test.cpp');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);

package/principles/adapters/__tests__/dart.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';;
 import { DartAdapter } from '../dart';
 
 vi.mock('fs', () => ({
@@ -10,7 +10,7 @@ import { readFileSync } from 'fs';
 
 describe('DartAdapter', () => {
   it('should implement the Adapter interface', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
     const adapter = new DartAdapter('test.dart');
     
     expect(adapter).toHaveProperty('detectLanguage');
@@ -21,24 +21,24 @@ describe('DartAdapter', () => {
   });
 
   it('should detect language as dart for .dart files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}');
     const adapter = new DartAdapter('test.dart');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('dart');
   });
 
   it('should parse Dart file AST correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
     const adapter = new DartAdapter('test.dart');
     const ast = adapter.parseAST();
     expect(ast).toHaveProperty('content');
     expect(ast).toHaveProperty('language');
     expect(ast).toHaveProperty('filePath');
-    expect(ast.language).toBe('dart');
+    expect((ast as { language: unknown }).language).toBe('dart');
   });
 
   it('should extract functions from Dart AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
     const adapter = new DartAdapter('test.dart');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
@@ -46,7 +46,7 @@ describe('DartAdapter', () => {
   });
 
   it('should extract classes from Dart AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
     const adapter = new DartAdapter('test.dart');
     const classes = adapter.extractClasses();
     expect(Array.isArray(classes)).toBe(true);
@@ -54,20 +54,20 @@ describe('DartAdapter', () => {
   });
 
   it('should count Dart file physical lines', () => {
-    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nvoid testFn2() {}');
+    (readFileSync as Mock).mockReturnValue('void testFn() {}\nvoid testFn2() {}');
     const adapter = new DartAdapter('test.dart');
     const lineCount = adapter.countLines();
     expect(lineCount).toBe(2);
   });
 
   it('should fall back to super.detectLanguage for non-dart extensions', () => {
-    (readFileSync as vi.Mock).mockReturnValue('content');
+    (readFileSync as Mock).mockReturnValue('content');
     const adapter = new DartAdapter('test.py');
     expect(adapter.detectLanguage()).toBe('python');
   });
 
   it('should handle async functions in Dart', () => {
-    (readFileSync as vi.Mock).mockReturnValue('Future<void> fetchData() async {}\nasync void fireAndForget() {}');
+    (readFileSync as Mock).mockReturnValue('Future<void> fetchData() async {}\nasync void fireAndForget() {}');
     const adapter = new DartAdapter('test.dart');
     const functions = adapter.extractFunctions();
     const asyncFns = functions.filter(fn => (fn as {type: string}).type === 'async_function');
@@ -75,7 +75,7 @@ describe('DartAdapter', () => {
   });
 
   it('should handle abstract class declarations in Dart', () => {
-    (readFileSync as vi.Mock).mockReturnValue('abstract class Repository {\n  void save();\n}\n');
+    (readFileSync as Mock).mockReturnValue('abstract class Repository {\n  void save();\n}\n');
     const adapter = new DartAdapter('test.dart');
     const classes = adapter.extractClasses();
     const abstractClasses = classes.filter(cls => (cls as {type: string}).type === 'abstract_class');

package/principles/adapters/__tests__/go.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';;
 import { GoAdapter } from '../go';
 
 vi.mock('fs', () => ({
@@ -10,7 +10,7 @@ import { readFileSync } from 'fs';
 
 describe('GoAdapter', () => {
   it('should implement the Adapter interface', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
     const adapter = new GoAdapter('test.go');
     
     expect(adapter).toHaveProperty('detectLanguage');
@@ -21,24 +21,24 @@ describe('GoAdapter', () => {
   });
 
   it('should detect language as go for .go files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}');
     const adapter = new GoAdapter('test.go');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('go');
   });
 
   it('should parse Go file AST correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
     const adapter = new GoAdapter('test.go');
     const ast = adapter.parseAST();
     expect(ast).toHaveProperty('content');
     expect(ast).toHaveProperty('language');
     expect(ast).toHaveProperty('filePath');
-    expect(ast.language).toBe('go');
+    expect((ast as { language: unknown }).language).toBe('go');
   });
 
   it('should extract functions from Go AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nfunc (t *TestClass) method() {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}\nfunc (t *TestClass) method() {}');
     const adapter = new GoAdapter('test.go');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
@@ -46,7 +46,7 @@ describe('GoAdapter', () => {
   });
 
   it('should extract structs from Go AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
     const adapter = new GoAdapter('test.go');
     const classes = adapter.extractClasses();
     expect(Array.isArray(classes)).toBe(true);
@@ -54,14 +54,14 @@ describe('GoAdapter', () => {
   });
 
   it('should count Go file physical lines', () => {
-    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nfunc testFn2() {}');
+    (readFileSync as Mock).mockReturnValue('func testFn() {}\nfunc testFn2() {}');
     const adapter = new GoAdapter('test.go');
     const lineCount = adapter.countLines();
     expect(lineCount).toBe(2);
   });
 
   it('should fall back to super.detectLanguage for non-go extensions', () => {
-    (readFileSync as vi.Mock).mockReturnValue('content');
+    (readFileSync as Mock).mockReturnValue('content');
     const adapter = new GoAdapter('test.ts');
     expect(adapter.detectLanguage()).toBe('typescript');
   });

package/principles/adapters/__tests__/java.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, type Mock } from 'vitest';;
 import { JavaAdapter } from '../java';
 
 vi.mock('fs', () => ({
@@ -10,7 +10,7 @@ import { readFileSync } from 'fs';
 
 describe('JavaAdapter', () => {
   it('should implement the Adapter interface', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
+    (readFileSync as Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
     const adapter = new JavaAdapter('Test.java');
     
     expect(adapter).toHaveProperty('detectLanguage');
@@ -21,24 +21,24 @@ describe('JavaAdapter', () => {
   });
 
   it('should detect language as java for .java files', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {}');
+    (readFileSync as Mock).mockReturnValue('public class Test {}');
     const adapter = new JavaAdapter('Test.java');
     const detected = adapter.detectLanguage();
     expect(detected).toBe('java');
   });
 
   it('should parse Java file AST correctly', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
+    (readFileSync as Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
     const adapter = new JavaAdapter('Test.java');
     const ast = adapter.parseAST();
     expect(ast).toHaveProperty('content');
     expect(ast).toHaveProperty('language');
     expect(ast).toHaveProperty('filePath');
-    expect(ast.language).toBe('java');
+    expect((ast as { language: unknown }).language).toBe('java');
   });
 
   it('should extract methods from Java AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
+    (readFileSync as Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
     const adapter = new JavaAdapter('Test.java');
     const functions = adapter.extractFunctions();
     expect(Array.isArray(functions)).toBe(true);
@@ -46,7 +46,7 @@ describe('JavaAdapter', () => {
   });
 
   it('should extract classes from Java AST', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
+    (readFileSync as Mock).mockReturnValue('public class Test {\n  public void testFn() {}\n}');
     const adapter = new JavaAdapter('Test.java');
     const classes = adapter.extractClasses();
     expect(Array.isArray(classes)).toBe(true);
@@ -54,14 +54,14 @@ describe('JavaAdapter', () => {
   });
 
   it('should count Java file physical lines', () => {
-    (readFileSync as vi.Mock).mockReturnValue('public class Test {\n}\nclass Test2 {}');
+    (readFileSync as Mock).mockReturnValue('public class Test {\n}\nclass Test2 {}');
     const adapter = new JavaAdapter('Test.java');
     const lineCount = adapter.countLines();
     expect(lineCount).toBe(3);
   });
 
   it('should fall back to super.detectLanguage for non-java extensions', () => {
-    (readFileSync as vi.Mock).mockReturnValue('content');
+    (readFileSync as Mock).mockReturnValue('content');
     const adapter = new JavaAdapter('test.ts');
     expect(adapter.detectLanguage()).toBe('typescript');
   });