@boyingliu01/xp-gate 0.8.8 → 0.8.10

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

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { JavaAdapter } from '../java';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+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}');
+    const adapter = new JavaAdapter('Test.java');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as java for .java files', () => {
+    (readFileSync as vi.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}');
+    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');
+  });
+
+  it('should extract methods from Java AST', () => {
+    (readFileSync as vi.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);
+    expect(functions.some(fn => (fn as {name: string}).name === 'testFn')).toBe(true);
+  });
+
+  it('should extract classes from Java AST', () => {
+    (readFileSync as vi.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);
+    expect(classes.some(cls => (cls as {name: string}).name === 'Test')).toBe(true);
+  });
+
+  it('should count Java file physical lines', () => {
+    (readFileSync as vi.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');
+    const adapter = new JavaAdapter('test.ts');
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+});

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

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest';
+import { KotlinAdapter } from '../kotlin';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('KotlinAdapter', () => {
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}\nclass TestClass');
+    const adapter = new KotlinAdapter('test.kt');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as kotlin for .kt files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}');
+    const adapter = new KotlinAdapter('test.kt');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('kotlin');
+  });
+
+  it('should parse Kotlin file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}\nclass TestClass');
+    const adapter = new KotlinAdapter('test.kt');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('kotlin');
+  });
+
+  it('should extract functions from Kotlin AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}\nclass TestClass');
+    const adapter = new KotlinAdapter('test.kt');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {name: string}).name === 'testFn')).toBe(true);
+  });
+
+  it('should extract classes from Kotlin AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}\nclass TestClass');
+    const adapter = new KotlinAdapter('test.kt');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'TestClass')).toBe(true);
+  });
+
+  it('should count Kotlin file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('fun testFn() {}\nfun testFn2() {}');
+    const adapter = new KotlinAdapter('test.kt');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should fall back to super.detectLanguage for non-kotlin extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new KotlinAdapter('test.ts');
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+
+  it('should handle suspend functions in Kotlin', () => {
+    (readFileSync as vi.Mock).mockReturnValue('suspend fun fetchData(): String { return "data" }');
+    const adapter = new KotlinAdapter('test.kt');
+    const functions = adapter.extractFunctions();
+    const suspendFns = functions.filter(fn => (fn as {type: string}).type === 'suspend_function');
+    expect(suspendFns.length).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,453 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ObjectiveCAdapter } from '../objectivec';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+/**
+ * @test REQ-QG-001 Language Coverage Extension
+ * @intent Verify Objective-C adapter implementation for quality gates
+ * @covers AC-QG-001-05, AC-QG-001-06, AC-QG-001-08
+ */
+describe('ObjectiveCAdapter', () => {
+  
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05
+   */
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('@implementation Test @end');
+    const adapter = new ObjectiveCAdapter('test.m');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-08
+   */
+  it('should detect language as objectivec for .m files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('@implementation Test @end');
+    const adapter = new ObjectiveCAdapter('test.m');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('objectivec');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-08
+   */
+  it('should detect language as objectivec for .mm files (Objective-C++)', () => {
+    (readFileSync as vi.Mock).mockReturnValue('@implementation Test @end');
+    const adapter = new ObjectiveCAdapter('test.mm');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('objectivec');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should parse Objective-C file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('@implementation Test @end');
+    const adapter = new ObjectiveCAdapter('test.m');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('objectivec');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract Objective-C instance methods', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation Calculator
+- (int)add:(int)a to:(int)b {
+  return a + b;
+}
+- (void)printResult {
+  NSLog(@"Result");
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Calculator.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.length).toBeGreaterThan(0);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract Objective-C class methods', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation StringUtils
++ (NSString *)trim:(NSString *)str {
+  return [str stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
+}
++ (BOOL)isEmpty:(NSString *)str {
+  return [str length] == 0;
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('StringUtils.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract C functions from Objective-C file', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+int helperFunction(int x) {
+  return x * 2;
+}
+
+void logDebug(const char *msg) {
+  printf("%s\\n", msg);
+}
+
+@implementation Helper
+- (void)process {
+  int result = helperFunction(5);
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Helper.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {type: string}).type === 'function')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract @implementation declarations', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation MyClass
+- (void)doSomething {}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('MyClass.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'MyClass')).toBe(true);
+    expect(classes.some(cls => (cls as {type: string}).type === 'implementation')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract @interface declarations', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@interface MyProtocol
+- (void)requiredMethod;
+@end
+`);
+    const adapter = new ObjectiveCAdapter('MyProtocol.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'MyProtocol')).toBe(true);
+    expect(classes.some(cls => (cls as {type: string}).type === 'interface')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle multiple @implementation blocks', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation FirstClass
+- (void)method1 {}
+@end
+
+@implementation SecondClass
+- (void)method2 {}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Multiple.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.length).toBeGreaterThanOrEqual(2);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle Objective-C inheritance syntax', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@interface ChildClass : ParentClass
+- (void)overrideMethod;
+@end
+`);
+    const adapter = new ObjectiveCAdapter('ChildClass.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'ChildClass')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle Objective-C categories', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation NSString (Extensions)
+- (NSString *)reversed {
+  // implementation
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Extensions.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle Objective-C properties', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@interface Person
+@property (nonatomic, strong) NSString *name;
+@property (nonatomic) NSInteger age;
+- (void)introduce;
+@end
+
+@implementation Person
+- (void)introduce {
+  NSLog(@"Hi, I'm %@", self.name);
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Person.m');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06, AC-QG-001-08
+   */
+  it('should handle Objective-C++ (.mm) files with C++ content', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+#import <Foundation/Foundation.h>
+#include <vector>
+
+@implementation MixedClass {
+  std::vector<int> _data;
+}
+
+- (void)processCpp {
+  _data.push_back(42);
+}
+
+@end
+`);
+    const adapter = new ObjectiveCAdapter('Mixed.mm');
+    expect(adapter.detectLanguage()).toBe('objectivec');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05
+   */
+  it('should count physical lines correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('@implementation Test\n- (void)method {}\n@end');
+    const adapter = new ObjectiveCAdapter('test.m');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(3);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle empty file', () => {
+    (readFileSync as vi.Mock).mockReturnValue('');
+    const adapter = new ObjectiveCAdapter('empty.m');
+    const functions = adapter.extractFunctions();
+    const classes = adapter.extractClasses();
+    expect(functions.length).toBe(0);
+    expect(classes.length).toBe(0);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle Objective-C literals and modern syntax', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation ModernObjC
+- (NSArray *)getItems {
+  return @[ @"one", @"two", @"three" ];
+}
+- (NSDictionary *)getDict {
+  return @{ @"key": @"value" };
+}
+- (NSNumber *)getNumber {
+  return @42;
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('ModernObjC.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should handle Objective-C blocks', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation BlockUser
+- (void)useBlock {
+  void (^myBlock)(void) = ^{
+    NSLog(@"Block executed");
+  };
+  myBlock();
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('BlockUser.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-08
+   */
+  it('should handle preprocessor directives', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+#import <Foundation/Foundation.h>
+#define MAX_SIZE 100
+
+#ifdef DEBUG
+@implementation DebugHelper
+- (void)logDebug {}
+@end
+#endif
+`);
+    const adapter = new ObjectiveCAdapter('Preprocessor.m');
+    expect(adapter.detectLanguage()).toBe('objectivec');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05
+   */
+  it('should throw error when file cannot be read', () => {
+    (readFileSync as vi.Mock).mockImplementation(() => {
+      throw new Error('Could not read file');
+    });
+    
+    expect(() => {
+      new ObjectiveCAdapter('nonexistent-file.m');
+    }).toThrow('Could not read file:');
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-06
+   */
+  it('should extract method with multiple parameters', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation MultiParam
+- (void)drawRect:(CGRect)rect withColor:(UIColor *)color andAlpha:(float)alpha {
+  // drawing code
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('MultiParam.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05, AC-QG-001-06
+   */
+  it('should handle static inline C functions', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+static inline int fastAdd(int a, int b) {
+  return a + b;
+}
+
+@implementation FastMath
+- (int)compute {
+  return fastAdd(1, 2);
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('FastMath.m');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {type: string}).type === 'function')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05
+   */
+  it('should extract line number for extracted elements', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation LineTest
+- (void)firstMethod {}
+- (void)secondMethod {}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('LineTest.m');
+    const functions = adapter.extractFunctions();
+    expect(functions.every(fn => typeof (fn as {line: number}).line === 'number')).toBe(true);
+  });
+
+  /**
+   * @test REQ-QG-001
+   * @covers AC-QG-001-05
+   */
+  it('should extract code block for methods', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+@implementation CodeBlockTest
+- (int)calculate {
+  int result = 0;
+  for (int i = 0; i < 10; i++) {
+    result += i;
+  }
+  return result;
+}
+@end
+`);
+    const adapter = new ObjectiveCAdapter('CodeBlockTest.m');
+    const functions = adapter.extractFunctions();
+    expect(functions.every(fn => typeof (fn as {code: string}).code === 'string')).toBe(true);
+  });
+
+  it('should fall back to super.detectLanguage for non-m/non-mm extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new ObjectiveCAdapter('test.ts');
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+});

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

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { PythonAdapter } from '../python';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('PythonAdapter', () => {
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass\nclass TestClass:');
+    const adapter = new PythonAdapter('test.py');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as python for .py files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass');
+    const adapter = new PythonAdapter('test.py');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('python');
+  });
+
+  it('should parse Python file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass\nclass TestClass:');
+    const adapter = new PythonAdapter('test.py');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('python');
+  });
+
+  it('should extract functions from Python AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass\nclass TestClass:');
+    const adapter = new PythonAdapter('test.py');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {name: string}).name === 'test_fn')).toBe(true);
+  });
+
+  it('should extract classes from Python AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass\nclass TestClass:');
+    const adapter = new PythonAdapter('test.py');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'TestClass')).toBe(true);
+  });
+
+  it('should count Python file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def test_fn(): pass\ndef test_fn2(): pass');
+    const adapter = new PythonAdapter('test.py');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should handle async functions in Python', () => {
+    (readFileSync as vi.Mock).mockReturnValue('async def async_fn(): pass');
+    const adapter = new PythonAdapter('test.py');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  it('should fall back to super.detectLanguage for non-py extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new PythonAdapter('test.ts');
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+
+  it('should extract code block with indented body', () => {
+    (readFileSync as vi.Mock).mockReturnValue('def outer():\n    inner()\n    return 0');
+    const adapter = new PythonAdapter('test.py');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.length).toBe(1);
+    expect((functions[0] as {name: string}).name).toBe('outer');
+  });
+});