@boyingliu01/xp-gate 0.8.9 → 0.8.10

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

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SwiftAdapter } from '../swift';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('SwiftAdapter', () => {
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nclass TestClass {}');
+    const adapter = new SwiftAdapter('test.swift');
+    
+    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 swift for .swift files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}');
+    const adapter = new SwiftAdapter('test.swift');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('swift');
+  });
+
+  it('should parse Swift file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nclass TestClass {}');
+    const adapter = new SwiftAdapter('test.swift');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('swift');
+  });
+
+  it('should extract functions from Swift AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nclass TestClass {}');
+    const adapter = new SwiftAdapter('test.swift');
+    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 Swift AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nclass TestClass {}');
+    const adapter = new SwiftAdapter('test.swift');
+    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 Swift file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nfunc testFn2() {}');
+    const adapter = new SwiftAdapter('test.swift');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should fall back to super.detectLanguage for non-swift extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new SwiftAdapter('test.py');
+    expect(adapter.detectLanguage()).toBe('python');
+  });
+});

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

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TypeScriptAdapter } from '../typescript';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('TypeScriptAdapter', () => {
+  
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    
+    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 typescript for .ts files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('typescript');
+  });
+
+  it('should detect language as typescript for .tsx files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.tsx');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('typescript');
+  });
+
+  it('should parse TypeScript file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('typescript');
+  });
+
+  it('should extract functions from TypeScript AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    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 TypeScript AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nclass TestClass {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    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 TypeScript file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export function testFn() {}\nexport function testFn2() {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should handle TypeScript-specific syntax correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+      export async function asyncFn() {}
+      export function* generatorFn() {}
+      class MyClass {
+        method() {}
+      }
+      interface MyInterface {}
+      type MyType = string;
+    `);
+    
+    const adapter = new TypeScriptAdapter('test.ts');
+    
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+  
+  it('should throw error when file cannot be read', () => {
+    (readFileSync as vi.Mock).mockImplementation(() => {
+      throw new Error('Could not read file');
+    });
+    
+    expect(() => {
+      new TypeScriptAdapter('nonexistent-file.ts');
+    }).toThrow('Could not read file:');
+  });
+
+  it('should fall back to super.detectLanguage for non-ts/non-tsx extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new TypeScriptAdapter('test.py');
+    expect(adapter.detectLanguage()).toBe('python');
+  });
+
+  it('should extract re-export declarations', () => {
+    (readFileSync as vi.Mock).mockReturnValue('export { Foo };\nexport { Bar };\nexport function baz() {}');
+    const adapter = new TypeScriptAdapter('test.ts');
+    const exports = adapter.extractExports();
+    const reExports = exports.filter(ex => (ex as {type: string}).type === 're-export');
+    expect(reExports.length).toBe(2);
+  });
+});

package/principles/adapters/base.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from 'fs';
+import { extname } from 'path';
+import { Adapter } from '../types';
+
+export abstract class BaseAdapter implements Adapter {
+  protected readonly filePath: string;
+  protected readonly fileContent: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+    this.fileContent = this.readFileContent(filePath);
+  }
+
+  detectLanguage(): string {
+    const extension = extname(this.filePath).toLowerCase();
+    
+    const languageMap: Record<string, string> = {
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.py': 'python',
+      '.go': 'go',
+      '.java': 'java',
+      '.kt': 'kotlin',
+      '.dart': 'dart',
+      '.swift': 'swift',
+    };
+
+    return languageMap[extension] || 'unknown';
+  }
+
+  abstract parseAST(): unknown;
+  abstract extractFunctions(): unknown[];
+  abstract extractClasses(): unknown[];
+
+  extractExports(): unknown[] {
+    return [];
+  }
+
+  protected createParseResult(language: string): unknown {
+    return {
+      content: this.fileContent,
+      language,
+      filePath: this.filePath,
+    };
+  }
+
+  protected createCodeMatch(name: string, type: string, index: number): unknown {
+    return {
+      name,
+      type,
+      line: this.getLineNumber(index),
+      code: this.extractCodeBlock(index),
+    };
+  }
+
+  countLines(): number {
+    return this.fileContent.split('\n').length;
+  }
+
+  protected readFileContent(filePath: string): string {
+    try {
+      return readFileSync(filePath, 'utf-8');
+    } catch {
+      throw new Error(`Could not read file: ${filePath}`);
+    }
+  }
+
+  protected getLineNumber(position: number): number {
+    return this.fileContent.substring(0, position).split('\n').length;
+  }
+
+  protected fallbackCodeBlock(startPos: number, maxFallback: number): string {
+    const code = this.fileContent.substring(startPos);
+    return code.substring(0, Math.min(maxFallback, code.length));
+  }
+
+  /**
+   * Advance brace tracker by one character. Returns updated state and signals when
+   * a balanced block closes so callers can break out of their scan loop.
+   */
+  protected advanceBraceTracker(
+    char: string,
+    index: number,
+    state: { inBlock: boolean; braceCount: number },
+  ): { closed: boolean; endPos: number } {
+    if (char === '{' && !state.inBlock) {
+      state.inBlock = true;
+      state.braceCount = 1;
+      return { closed: false, endPos: index };
+    }
+    if (char === '{' && state.inBlock) {
+      state.braceCount += 1;
+      return { closed: false, endPos: index };
+    }
+    if (char === '}' && state.inBlock) {
+      state.braceCount -= 1;
+      if (state.braceCount === 0) {
+        return { closed: true, endPos: index + 1 };
+      }
+    }
+    return { closed: false, endPos: index };
+  }
+
+  protected extractCodeBlock(startPos: number, maxFallback: number = 100): string {
+    const state = { inBlock: false, braceCount: 0 };
+    let endPos = startPos;
+
+    for (let i = startPos; i < this.fileContent.length; i++) {
+      const result = this.advanceBraceTracker(this.fileContent[i], i, state);
+      if (result.closed) {
+        endPos = result.endPos;
+        break;
+      }
+    }
+
+    if (endPos > startPos) {
+      return this.fileContent.substring(startPos, endPos);
+    }
+
+    return this.fallbackCodeBlock(startPos, maxFallback);
+  }
+}

package/principles/adapters/cpp.ts

@@ -0,0 +1,115 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class CppAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.cpp') || ext.endsWith('.cxx') || ext.endsWith('.cc') ||
+        ext.endsWith('.c') || ext.endsWith('.hpp') || ext.endsWith('.h')) {
+      return 'cpp';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return this.createParseResult('cpp');
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /(\w+[\s*]+)+([\w:]+[:]+)?([~]?\w+)\s*\([^)]*\)\s*(const\s*)?\s*(override\s*)?\s*(final\s*)?\s*(noexcept\s*)?\s*(->\s*[\w<>:&*\s]+)?\s*[{;]/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      const funcName = match[3] || 'unknown';
+      const fullName = match[2] ? match[2] + funcName : funcName;
+
+      functionMatches.push(this.createCodeMatch(fullName.replace(/::$/, ''), 'function', match.index));
+    }
+
+    const constructorRegex = /([\w:]+)\s*\([^)]*\)\s*:\s*[\w_]+\s*\([^)]*\)/g;
+    while ((match = constructorRegex.exec(this.fileContent)) !== null) {
+      const constructorName = match[1];
+
+      functionMatches.push(this.createCodeMatch(constructorName, 'constructor', match.index));
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /\b(class|struct)\s+(\w+)\s*(:\s*(public|protected|private)\s+[\w:]+)?\s*\{/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push(this.createCodeMatch(match[2], match[1], match.index));
+    }
+
+    return classMatches;
+  }
+
+  override extractCodeBlock(startPos: number, maxFallback: number = 200): string {
+    const state = { inBlock: false, braceCount: 0 };
+    let endPos = startPos;
+    let inString = false;
+    let stringChar = '';
+    let inComment = false;
+
+    for (let i = startPos; i < this.fileContent.length; i++) {
+      const char = this.fileContent[i];
+      const nextChar = this.fileContent[i + 1] || '';
+
+      if (!inString && !inComment) {
+        if (char === '/' && nextChar === '/') {
+          while (i < this.fileContent.length && this.fileContent[i] !== '\n') {
+            i++;
+          }
+          continue;
+        }
+        if (char === '/' && nextChar === '*') {
+          inComment = true;
+          i++;
+          continue;
+        }
+      } else if (inComment) {
+        if (char === '*' && nextChar === '/') {
+          inComment = false;
+          i++;
+        }
+        continue;
+      }
+
+      if (!inComment) {
+        if (!inString && (char === '"' || char === "'")) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar) {
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && this.fileContent[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+      }
+
+      if (!inString && !inComment) {
+        const result = this.advanceBraceTracker(char, i, state);
+        if (result.closed) {
+          endPos = result.endPos;
+          break;
+        }
+      }
+    }
+
+    if (endPos > startPos) {
+      return this.fileContent.substring(startPos, endPos);
+    }
+
+    return this.fallbackCodeBlock(startPos, maxFallback);
+  }
+}

package/principles/adapters/dart.ts

@@ -0,0 +1,44 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class DartAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.dart')) {
+      return 'dart';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return this.createParseResult('dart');
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /(async\s+)?[\w<>]+\s+(\w+)\s*\([^)]*\)\s*(async\s*)?\s*{/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      if (match[2] !== 'class' && match[2] !== 'interface' && match[2] !== 'abstract') {
+        const type = match[1] ? 'async_function' : 'function';
+        functionMatches.push(this.createCodeMatch(match[2], type, match.index));
+      }
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /(abstract\s+)?class\s+(\w+)\s*(extends\s+\w+)?\s*(with\s+[\w,\s]+)?\s*(implements\s+[\w,\s]+)?\s*{/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      const type = match[1] ? 'abstract_class' : 'class';
+      classMatches.push(this.createCodeMatch(match[2], type, match.index));
+    }
+
+    return classMatches;
+  }
+}

package/principles/adapters/go.ts

@@ -0,0 +1,55 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class GoAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.go')) {
+      return 'go';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return {
+      content: this.fileContent,
+      language: 'go',
+      filePath: this.filePath
+    };
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /func\s+(\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\([^)]*\)\s*({)?/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push({
+        name: match[2],
+        type: match[1] ? 'method' : 'function',
+        receiver: match[1] ? match[1].trim() : null,
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const structMatches = [];
+    const structRegex = /type\s+(\w+)\s+struct\s*{/g;
+    let match;
+
+    while ((match = structRegex.exec(this.fileContent)) !== null) {
+      structMatches.push({
+        name: match[1],
+        type: 'struct',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return structMatches;
+  }
+}

package/principles/adapters/java.ts

@@ -0,0 +1,56 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class JavaAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.java')) {
+      return 'java';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return {
+      content: this.fileContent,
+      language: 'java',
+      filePath: this.filePath
+    };
+  }
+
+  extractFunctions(): unknown[] {
+    const methodMatches = [];
+    const methodRegex = /(public|private|protected|static|final|synchronized|native)\s+[\w<>[\]]+\s+(\w+)\s*\([^)]*\)\s*(throws\s+[\w,\s]+)?\s*{/g;
+    let match;
+
+    while ((match = methodRegex.exec(this.fileContent)) !== null) {
+      methodMatches.push({
+        name: match[2],
+        type: 'method',
+        modifiers: match[1].split(' ').filter(m => m.trim()),
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return methodMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /(public|private|protected)?\s*(abstract|final|static)?\s*class\s+(\w+)\s*(extends\s+\w+)?\s*(implements\s+[\w,\s]+)?\s*{/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push({
+        name: match[3],
+        type: 'class',
+        modifiers: [match[1], match[2]].filter(m => m && m.trim()),
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return classMatches;
+  }
+}

package/principles/adapters/kotlin.ts

@@ -0,0 +1,54 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class KotlinAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.kt') || ext.endsWith('.kts')) {
+      return 'kotlin';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return {
+      content: this.fileContent,
+      language: 'kotlin',
+      filePath: this.filePath
+    };
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /(suspend\s+)?fun\s+(\w+)\s*\([^)]*\)\s*(:\s*[\w<>?]+)?\s*{/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push({
+        name: match[2],
+        type: match[1] ? 'suspend_function' : 'function',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /class\s+(\w+)/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push({
+        name: match[1],
+        type: 'class',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return classMatches;
+  }
+}