@ddse/acm-aicoder 0.5.0 → 0.5.2

package/src/context/context-pack.ts

@@ -1,133 +0,0 @@
-// Context Pack Generator - Create rich context for LLM planning
-import type { 
-  ContextPack, 
-  WorkspaceIndex, 
-  SymbolInfo, 
-  DependencyInfo, 
-  TestMapping 
-} from './types.js';
-import { CodeSearch } from './code-search.js';
-
-export interface ContextPackOptions {
-  maxFiles?: number;
-  maxSymbols?: number;
-  includeTests?: boolean;
-  includeDependencies?: boolean;
-}
-
-export class ContextPackGenerator {
-  private search: CodeSearch;
-
-  constructor(search: CodeSearch) {
-    this.search = search;
-  }
-
-  /**
-   * Generate context pack for a goal
-   */
-  async generate(
-    goal: string,
-    index: WorkspaceIndex,
-    symbols: SymbolInfo[],
-    dependencies: DependencyInfo[],
-    testMappings: TestMapping[],
-    options: ContextPackOptions = {}
-  ): Promise<ContextPack> {
-    const maxFiles = options.maxFiles ?? 8;
-    const maxSymbols = options.maxSymbols ?? 20;
-    const normalizedGoal = (goal || '').toString();
-    const searchQuery = normalizedGoal.trim().length > 0
-      ? normalizedGoal
-      : 'workspace overview';
-
-    // Search for relevant files
-    const searchResults = await this.search.search(searchQuery, {
-      k: maxFiles,
-      includeContext: true,
-      contextLines: 2,
-    });
-
-    // Extract relevant symbols (top matching symbols)
-    const relevantSymbols = this.findRelevantSymbols(normalizedGoal, symbols, maxSymbols);
-
-    // Filter dependencies if requested
-    const relevantDeps = options.includeDependencies 
-      ? dependencies.slice(0, 20) // Top 20 deps
-      : [];
-
-    // Extract test files if requested
-    const testFiles = options.includeTests
-      ? testMappings.map(m => m.testFile)
-      : [];
-
-    // Build context pack
-    const pack: ContextPack = {
-      goal: normalizedGoal,
-      files: searchResults.map(r => ({
-        path: r.path,
-        snippet: r.snippet,
-        relevance: r.score,
-      })),
-      symbols: relevantSymbols,
-      dependencies: relevantDeps,
-      testFiles,
-      summary: this.generateSummary(index, searchResults.length, relevantSymbols.length),
-      generatedAt: new Date().toISOString(),
-    };
-
-    return pack;
-  }
-
-  /**
-   * Find symbols relevant to the goal
-   */
-  private findRelevantSymbols(goal: string, symbols: SymbolInfo[], limit: number): SymbolInfo[] {
-    const goalLower = (goal || '').toLowerCase();
-    const tokens = goalLower.split(/\s+/).filter(Boolean);
-
-    if (tokens.length === 0) {
-      return [];
-    }
-
-    // Score symbols by relevance
-    const scored = symbols.map(symbol => {
-      let score = 0;
-      const nameLower = symbol.name.toLowerCase();
-
-      // Exact match
-      if (tokens.some(t => nameLower === t)) {
-        score += 10;
-      }
-
-      // Partial match
-      if (tokens.some(t => nameLower.includes(t) || t.includes(nameLower))) {
-        score += 5;
-      }
-
-      // Boost exported symbols
-      if (symbol.kind === 'function' || symbol.kind === 'class') {
-        score += 2;
-      }
-
-      return { symbol, score };
-    });
-
-    // Sort by score and return top symbols
-    return scored
-      .filter(s => s.score > 0)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, limit)
-      .map(s => s.symbol);
-  }
-
-  /**
-   * Generate a summary of the context
-   */
-  private generateSummary(index: WorkspaceIndex, fileCount: number, symbolCount: number): string {
-    const totalFiles = index.totalFiles;
-    const totalSize = (index.totalSize / 1024 / 1024).toFixed(2);
-
-    return `Workspace: ${totalFiles} files, ${totalSize}MB. ` +
-           `Context: ${fileCount} relevant files, ${symbolCount} symbols.`;
-  }
-}

package/src/context/dependency-mapper.ts

@@ -1,72 +0,0 @@
-// Dependency Mapper - Parse and analyze dependencies
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { DependencyInfo, WorkspaceIndex } from './types.js';
-
-export class DependencyMapper {
-  private rootPath: string;
-
-  constructor(rootPath: string) {
-    this.rootPath = rootPath;
-  }
-
-  /**
-   * Extract dependencies from package.json files
-   */
-  async extractDependencies(index: WorkspaceIndex): Promise<DependencyInfo[]> {
-    const dependencies: DependencyInfo[] = [];
-
-    // Find all package.json files
-    const packageFiles = index.files.filter(f => 
-      path.basename(f.path) === 'package.json'
-    );
-
-    for (const file of packageFiles) {
-      try {
-        const fullPath = path.join(this.rootPath, file.path);
-        const content = await fs.readFile(fullPath, 'utf-8');
-        const pkg = JSON.parse(content);
-
-        // Extract dependencies
-        if (pkg.dependencies) {
-          for (const [name, version] of Object.entries(pkg.dependencies)) {
-            dependencies.push({
-              name,
-              version: version as string,
-              type: 'dependency',
-              packageJsonPath: file.path,
-            });
-          }
-        }
-
-        // Extract devDependencies
-        if (pkg.devDependencies) {
-          for (const [name, version] of Object.entries(pkg.devDependencies)) {
-            dependencies.push({
-              name,
-              version: version as string,
-              type: 'devDependency',
-              packageJsonPath: file.path,
-            });
-          }
-        }
-
-        // Extract peerDependencies
-        if (pkg.peerDependencies) {
-          for (const [name, version] of Object.entries(pkg.peerDependencies)) {
-            dependencies.push({
-              name,
-              version: version as string,
-              type: 'peerDependency',
-              packageJsonPath: file.path,
-            });
-          }
-        }
-      } catch {
-        // Skip invalid package.json files
-      }
-    }
-
-    return dependencies;
-  }
-}

package/src/context/index.ts

@@ -1,8 +0,0 @@
-// Context Engine - Intelligent repository understanding
-export * from './workspace-indexer.js';
-export * from './symbol-extractor.js';
-export * from './dependency-mapper.js';
-export * from './test-mapper.js';
-export * from './code-search.js';
-export * from './context-pack.js';
-export * from './types.js';

package/src/context/symbol-extractor.ts

@@ -1,149 +0,0 @@
-// Symbol Extractor - Extract symbols from TypeScript/JavaScript files
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { SymbolInfo, WorkspaceIndex } from './types.js';
-
-/**
- * Simple symbol extractor using regex patterns
- * For production use, consider ts-morph or @typescript/vfs
- */
-export class SymbolExtractor {
-  private rootPath: string;
-
-  constructor(rootPath: string) {
-    this.rootPath = rootPath;
-  }
-
-  /**
-   * Extract symbols from indexed files
-   */
-  async extractSymbols(index: WorkspaceIndex): Promise<SymbolInfo[]> {
-    const symbols: SymbolInfo[] = [];
-
-    // Filter to TS/JS files
-    const codeFiles = index.files.filter(f => 
-      (f.language === 'typescript' || f.language === 'javascript') &&
-      !f.isBinary &&
-      f.size < 500_000
-    );
-
-    for (const file of codeFiles) {
-      try {
-        const fullPath = path.join(this.rootPath, file.path);
-        const content = await fs.readFile(fullPath, 'utf-8');
-        const fileSymbols = this.parseSymbols(content, file.path);
-        symbols.push(...fileSymbols);
-      } catch {
-        // Skip files we can't read
-      }
-    }
-
-    return symbols;
-  }
-
-  /**
-   * Parse symbols from file content using regex
-   */
-  private parseSymbols(content: string, filePath: string): SymbolInfo[] {
-    const symbols: SymbolInfo[] = [];
-    const lines = content.split('\n');
-
-    // Patterns for different symbol types
-    const patterns = {
-      function: /(?:export\s+)?(?:async\s+)?function\s+(\w+)/g,
-      class: /(?:export\s+)?class\s+(\w+)/g,
-      interface: /(?:export\s+)?interface\s+(\w+)/g,
-      type: /(?:export\s+)?type\s+(\w+)/g,
-      const: /(?:export\s+)?const\s+(\w+)/g,
-      let: /(?:export\s+)?let\s+(\w+)/g,
-      var: /(?:export\s+)?var\s+(\w+)/g,
-    };
-
-    lines.forEach((line, idx) => {
-      const lineNum = idx + 1;
-
-      // Extract functions
-      const functionMatches = line.matchAll(patterns.function);
-      for (const match of functionMatches) {
-        symbols.push({
-          name: match[1],
-          kind: 'function',
-          path: filePath,
-          line: lineNum,
-          signature: line.trim(),
-        });
-      }
-
-      // Extract classes
-      const classMatches = line.matchAll(patterns.class);
-      for (const match of classMatches) {
-        symbols.push({
-          name: match[1],
-          kind: 'class',
-          path: filePath,
-          line: lineNum,
-        });
-      }
-
-      // Extract interfaces
-      const interfaceMatches = line.matchAll(patterns.interface);
-      for (const match of interfaceMatches) {
-        symbols.push({
-          name: match[1],
-          kind: 'interface',
-          path: filePath,
-          line: lineNum,
-        });
-      }
-
-      // Extract types
-      const typeMatches = line.matchAll(patterns.type);
-      for (const match of typeMatches) {
-        symbols.push({
-          name: match[1],
-          kind: 'type',
-          path: filePath,
-          line: lineNum,
-        });
-      }
-
-      // Extract exports (const/let/var)
-      if (line.includes('export')) {
-        for (const [pattern, kind] of [
-          [patterns.const, 'export'],
-          [patterns.let, 'export'],
-          [patterns.var, 'export'],
-        ] as const) {
-          const matches = line.matchAll(pattern);
-          for (const match of matches) {
-            symbols.push({
-              name: match[1],
-              kind,
-              path: filePath,
-              line: lineNum,
-            });
-          }
-        }
-      }
-    });
-
-    return symbols;
-  }
-
-  /**
-   * Find symbol definition by name
-   */
-  static findSymbol(symbols: SymbolInfo[], name: string): SymbolInfo[] {
-    return symbols.filter(s => 
-      s.name === name || s.name.toLowerCase() === name.toLowerCase()
-    );
-  }
-
-  /**
-   * Get symbols by kind
-   */
-  static filterByKind(symbols: SymbolInfo[], kinds: SymbolInfo['kind'][]): SymbolInfo[] {
-    const kindSet = new Set(kinds);
-    return symbols.filter(s => kindSet.has(s.kind));
-  }
-}

package/src/context/test-mapper.ts

@@ -1,77 +0,0 @@
-// Test Mapper - Identify test files and their targets
-import * as path from 'path';
-import type { TestMapping, WorkspaceIndex } from './types.js';
-
-const TEST_PATTERNS = [
-  /\.test\.(ts|tsx|js|jsx)$/,
-  /\.spec\.(ts|tsx|js|jsx)$/,
-  /__tests__\//,
-  /\.test\..*$/,
-];
-
-export class TestMapper {
-  /**
-   * Map test files to their likely source targets
-   */
-  static mapTests(index: WorkspaceIndex): TestMapping[] {
-    const mappings: TestMapping[] = [];
-
-    // Find test files
-    const testFiles = index.files.filter(f => 
-      TEST_PATTERNS.some(pattern => pattern.test(f.path))
-    );
-
-    for (const testFile of testFiles) {
-      // Try to infer source file
-      const targetFiles = this.inferTargetFiles(testFile.path, index);
-      
-      // Detect test framework
-      const framework = this.detectFramework(testFile.path);
-
-      mappings.push({
-        testFile: testFile.path,
-        targetFiles,
-        testFramework: framework,
-      });
-    }
-
-    return mappings;
-  }
-
-  /**
-   * Infer target source files from test file path
-   */
-  private static inferTargetFiles(testPath: string, index: WorkspaceIndex): string[] {
-    const targets: string[] = [];
-
-    // Remove test suffix/prefix patterns
-    let basePath = testPath
-      .replace(/\.test\.(ts|tsx|js|jsx)$/, '.$1')
-      .replace(/\.spec\.(ts|tsx|js|jsx)$/, '.$1')
-      .replace(/__tests__\//, '');
-
-    // Check if this file exists
-    if (index.files.some(f => f.path === basePath)) {
-      targets.push(basePath);
-    }
-
-    // Try src/ variant
-    const srcPath = path.join('src', path.basename(basePath));
-    if (index.files.some(f => f.path === srcPath)) {
-      targets.push(srcPath);
-    }
-
-    return targets;
-  }
-
-  /**
-   * Detect test framework from file path
-   */
-  private static detectFramework(testPath: string): string | undefined {
-    if (testPath.includes('jest')) return 'jest';
-    if (testPath.includes('mocha')) return 'mocha';
-    if (testPath.includes('vitest')) return 'vitest';
-    if (testPath.includes('spec')) return 'jasmine';
-    return undefined;
-  }
-}

package/src/context/types.ts

@@ -1,69 +0,0 @@
-// Context Engine Types
-
-export interface FileMetadata {
-  path: string;
-  size: number;
-  mtime: number;
-  hash: string;
-  language: string;
-  isBinary: boolean;
-}
-
-export interface WorkspaceIndex {
-  files: FileMetadata[];
-  totalFiles: number;
-  totalSize: number;
-  indexedAt: string;
-  rootPath: string;
-}
-
-export interface SymbolInfo {
-  name: string;
-  kind: 'function' | 'class' | 'variable' | 'interface' | 'type' | 'export' | 'import';
-  path: string;
-  line: number;
-  column?: number;
-  signature?: string;
-}
-
-export interface DependencyInfo {
-  name: string;
-  version: string;
-  type: 'dependency' | 'devDependency' | 'peerDependency';
-  packageJsonPath: string;
-}
-
-export interface ImportGraph {
-  [filePath: string]: {
-    imports: string[];
-    exportedSymbols: string[];
-  };
-}
-
-export interface TestMapping {
-  testFile: string;
-  targetFiles: string[];
-  testFramework?: string;
-}
-
-export interface SearchResult {
-  path: string;
-  score: number;
-  snippet: string;
-  line: number;
-  column?: number;
-}
-
-export interface ContextPack {
-  goal: string;
-  files: Array<{
-    path: string;
-    snippet: string;
-    relevance: number;
-  }>;
-  symbols: SymbolInfo[];
-  dependencies: DependencyInfo[];
-  testFiles: string[];
-  summary: string;
-  generatedAt: string;
-}