@ddse/acm-aicoder 0.5.0

package/src/tools-v2/read-tools.ts

@@ -0,0 +1,286 @@
+// Enhanced Code Tools - Reading, Searching, and Comparison
+import { Tool } from '@ddse/acm-sdk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/**
+ * FileStatTool - Check file existence, size, type
+ */
+export class FileStatTool extends Tool<
+  { path: string },
+  { exists: boolean; size: number; mtime: number; isBinary: boolean }
+> {
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'file_stat';
+  }
+
+  async call(input: { path: string }): Promise<{
+    exists: boolean;
+    size: number;
+    mtime: number;
+    isBinary: boolean;
+  }> {
+    const targetPath = this.resolvePath(input.path);
+
+    try {
+      const stats = await fs.stat(targetPath);
+      const ext = path.extname(targetPath);
+      const binaryExts = new Set(['.png', '.jpg', '.pdf', '.zip', '.exe', '.dll']);
+      
+      return {
+        exists: true,
+        size: stats.size,
+        mtime: stats.mtimeMs,
+        isBinary: binaryExts.has(ext),
+      };
+    } catch {
+      return {
+        exists: false,
+        size: 0,
+        mtime: 0,
+        isBinary: false,
+      };
+    }
+  }
+
+  private resolvePath(filePath: string): string {
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(this.rootPath, filePath);
+  }
+}
+
+/**
+ * FileReadTool - Read files with offset/limit for large files
+ */
+export class FileReadToolV2 extends Tool<
+  { path: string; offset?: number; limit?: number; ranges?: Array<{ start: number; end: number }> },
+  { content: string; bytesRead: number; eof: boolean; lang?: string }
+> {
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'file_read_v2';
+  }
+
+  async call(input: { 
+    path: string; 
+    offset?: number; 
+    limit?: number;
+    ranges?: Array<{ start: number; end: number }>;
+  }): Promise<{ content: string; bytesRead: number; eof: boolean; lang?: string }> {
+    // Normalize common aliases for file path (planner may emit `filepath` or `filePath`)
+    const anyInput = input as any;
+    const normalizedPath: string | undefined = anyInput?.path ?? anyInput?.filepath ?? anyInput?.filePath;
+    if (!normalizedPath) {
+      throw new Error('FileReadToolV2: missing required path. Accepted keys: path | filepath | filePath');
+    }
+  const fullPath = this.resolvePath(normalizedPath);
+    const stats = await fs.stat(fullPath);
+    
+    // Check if binary
+    const ext = path.extname(normalizedPath);
+    const binaryExts = new Set(['.png', '.jpg', '.pdf', '.zip', '.exe', '.dll']);
+    if (binaryExts.has(ext)) {
+      throw new Error(`File ${normalizedPath} is binary, cannot read as text`);
+    }
+
+    // Handle ranged reads
+    if (input.ranges && input.ranges.length > 0) {
+  const content = await fs.readFile(fullPath, 'utf-8');
+      const rangeContents = input.ranges.map(range => 
+        content.slice(range.start, range.end)
+      );
+      return {
+        content: rangeContents.join('\n---\n'),
+        bytesRead: rangeContents.reduce((sum, c) => sum + c.length, 0),
+        eof: true,
+        lang: this.detectLanguage(ext),
+      };
+    }
+
+    // Handle offset/limit reads
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? stats.size;
+
+  const content = await fs.readFile(fullPath, 'utf-8');
+    const slice = content.slice(offset, offset + limit);
+    const eof = offset + slice.length >= content.length;
+
+    return {
+      content: slice,
+      bytesRead: slice.length,
+      eof,
+      lang: this.detectLanguage(ext),
+    };
+  }
+
+  private detectLanguage(ext: string): string {
+    const langMap: Record<string, string> = {
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.py': 'python',
+      '.go': 'go',
+      '.rs': 'rust',
+    };
+    return langMap[ext] || 'text';
+  }
+
+  private resolvePath(filePath: string): string {
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(this.rootPath, filePath);
+  }
+}
+
+/**
+ * FileReadLinesTool - Line-ranged reading for precision
+ */
+export class FileReadLinesTool extends Tool<
+  { path: string; startLine?: number; endLine?: number; maxLines?: number },
+  { content: string; startLine: number; endLine: number; totalLines?: number }
+> {
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'file_read_lines';
+  }
+
+  async call(input: { 
+    path: string; 
+    startLine?: number; 
+    endLine?: number;
+    maxLines?: number;
+  }): Promise<{ content: string; startLine: number; endLine: number; totalLines?: number }> {
+    // Normalize common aliases for file path (planner may emit `filepath` or `filePath`)
+    const anyInput = input as any;
+    const normalizedPath: string | undefined = anyInput?.path ?? anyInput?.filepath ?? anyInput?.filePath;
+    if (!normalizedPath) {
+      throw new Error('FileReadLinesTool: missing required path. Accepted keys: path | filepath | filePath');
+    }
+  const fullPath = this.resolvePath(normalizedPath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    const lines = content.split('\n');
+    
+    const startLine = Math.max(1, input.startLine ?? 1);
+    const maxLines = input.maxLines ?? 100;
+    const endLine = input.endLine 
+      ? Math.min(lines.length, input.endLine)
+      : Math.min(lines.length, startLine + maxLines - 1);
+
+    // Extract lines (convert from 1-based to 0-based indexing)
+    const selectedLines = lines.slice(startLine - 1, endLine);
+    
+    return {
+      content: selectedLines.join('\n'),
+      startLine,
+      endLine,
+      totalLines: lines.length,
+    };
+  }
+
+  private resolvePath(filePath: string): string {
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(this.rootPath, filePath);
+  }
+}
+
+/**
+ * DiffTool - Generate unified diffs
+ */
+export class DiffTool extends Tool<
+  { aPath?: string; aContent?: string; bPath?: string; bContent?: string; context?: number },
+  { diff: string; stats: { filesChanged: number; additions: number; deletions: number } }
+> {
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'diff';
+  }
+
+  async call(input: { 
+    aPath?: string; 
+    aContent?: string; 
+    bPath?: string; 
+    bContent?: string;
+    context?: number;
+  }): Promise<{ diff: string; stats: { filesChanged: number; additions: number; deletions: number } }> {
+    // Get content from paths or direct content
+    const resolvedAPath = input.aPath ? this.resolvePath(input.aPath) : undefined;
+    const resolvedBPath = input.bPath ? this.resolvePath(input.bPath) : undefined;
+
+    const aContent = input.aContent ?? (resolvedAPath ? await fs.readFile(resolvedAPath, 'utf-8') : '');
+    const bContent = input.bContent ?? (resolvedBPath ? await fs.readFile(resolvedBPath, 'utf-8') : '');
+
+    // Simple line-by-line diff
+    const aLines = aContent.split('\n');
+    const bLines = bContent.split('\n');
+
+    const diff: string[] = [];
+    diff.push(`--- ${resolvedAPath || 'a'}`);
+    diff.push(`+++ ${resolvedBPath || 'b'}`);
+
+    let additions = 0;
+    let deletions = 0;
+
+    // Very simple diff (not optimal, but functional)
+    const maxLen = Math.max(aLines.length, bLines.length);
+    for (let i = 0; i < maxLen; i++) {
+      const aLine = aLines[i];
+      const bLine = bLines[i];
+
+      if (aLine !== bLine) {
+        if (aLine !== undefined) {
+          diff.push(`-${aLine}`);
+          deletions++;
+        }
+        if (bLine !== undefined) {
+          diff.push(`+${bLine}`);
+          additions++;
+        }
+      } else if (aLine !== undefined) {
+        diff.push(` ${aLine}`);
+      }
+    }
+
+    return {
+      diff: diff.join('\n'),
+      stats: {
+        filesChanged: 1,
+        additions,
+        deletions,
+      },
+    };
+  }
+
+  private resolvePath(filePath: string): string {
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(this.rootPath, filePath);
+  }
+}

package/src/tools-v2/search-tools.ts

@@ -0,0 +1,175 @@
+// Search Tools - Code search and pattern matching
+import { Tool } from '@ddse/acm-sdk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { CodeSearch, type SearchResult as ContextSearchResult } from '../context/index.js';
+import { WorkspaceIndexer } from '../context/index.js';
+
+/**
+ * CodeSearchTool - BM25-based code search
+ */
+export class CodeSearchTool extends Tool<
+  { query: string; k?: number; preferTypes?: string[]; includeContext?: boolean },
+  { results: Array<{ path: string; score: number; snippet: string; line: number }> }
+> {
+  private search: CodeSearch | null = null;
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'code_search';
+  }
+
+  async call(input: { 
+    query: string; 
+    k?: number; 
+    preferTypes?: string[];
+    includeContext?: boolean;
+  }): Promise<{ results: Array<{ path: string; score: number; snippet: string; line: number }> }> {
+    // Lazy initialize search
+    if (!this.search) {
+      this.search = new CodeSearch(this.rootPath);
+      const indexer = new WorkspaceIndexer(this.rootPath);
+      const index = await indexer.buildIndex({ useCache: true });
+      await this.search.indexFiles(index);
+    }
+
+    const results = await this.search.search(input.query, {
+      k: input.k ?? 10,
+      preferTypes: input.preferTypes,
+      includeContext: input.includeContext ?? true,
+      contextLines: 2,
+    });
+
+    return {
+      results: results.map(r => ({
+        path: r.path,
+        score: r.score,
+        snippet: r.snippet,
+        line: r.line,
+      })),
+    };
+  }
+}
+
+/**
+ * GrepTool - Pattern-based multi-file search
+ */
+export class GrepTool extends Tool<
+  { pattern: string; globs?: string[]; regex?: boolean; caseInsensitive?: boolean; maxResults?: number },
+  { matches: Array<{ path: string; line: number; column: number; preview: string }> }
+> {
+  private rootPath: string;
+
+  constructor(rootPath: string = process.cwd()) {
+    super();
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  name(): string {
+    return 'grep';
+  }
+
+  async call(input: { 
+    pattern: string; 
+    globs?: string[];
+    regex?: boolean;
+    caseInsensitive?: boolean;
+    maxResults?: number;
+  }): Promise<{ matches: Array<{ path: string; line: number; column: number; preview: string }> }> {
+    const maxResults = input.maxResults ?? 100;
+    const matches: Array<{ path: string; line: number; column: number; preview: string }> = [];
+
+    // Build pattern
+    let searchPattern: RegExp;
+    if (input.regex) {
+      const flags = input.caseInsensitive ? 'gi' : 'g';
+      searchPattern = new RegExp(input.pattern, flags);
+    } else {
+      const escaped = input.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const flags = input.caseInsensitive ? 'gi' : 'g';
+      searchPattern = new RegExp(escaped, flags);
+    }
+
+    // Scan files
+    await this.scanDirectory(this.rootPath, searchPattern, matches, maxResults);
+
+    return { matches };
+  }
+
+  private async scanDirectory(
+    dir: string,
+    pattern: RegExp,
+    matches: Array<{ path: string; line: number; column: number; preview: string }>,
+    maxResults: number
+  ): Promise<void> {
+    if (matches.length >= maxResults) return;
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (matches.length >= maxResults) break;
+
+        // Skip common directories
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+          continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          await this.scanDirectory(fullPath, pattern, matches, maxResults);
+        } else if (entry.isFile()) {
+          // Only search text files
+          const ext = path.extname(entry.name);
+          if (['.ts', '.tsx', '.js', '.jsx', '.md', '.json'].includes(ext)) {
+            await this.searchFile(fullPath, pattern, matches, maxResults);
+          }
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  private async searchFile(
+    filePath: string,
+    pattern: RegExp,
+    matches: Array<{ path: string; line: number; column: number; preview: string }>,
+    maxResults: number
+  ): Promise<void> {
+    if (matches.length >= maxResults) return;
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const relativePath = path.relative(this.rootPath, filePath);
+
+      for (let i = 0; i < lines.length; i++) {
+        if (matches.length >= maxResults) break;
+
+        const line = lines[i];
+        const match = pattern.exec(line);
+
+        if (match) {
+          matches.push({
+            path: relativePath,
+            line: i + 1,
+            column: match.index,
+            preview: line.substring(0, 100), // First 100 chars
+          });
+        }
+
+        // Reset lastIndex for global regex
+        pattern.lastIndex = 0;
+      }
+    } catch {
+      // Skip files we can't read
+    }
+  }
+}

package/src/tools-v2/test-tools.ts

@@ -0,0 +1,147 @@
+// Test and Build Tools
+import { Tool } from '@ddse/acm-sdk';
+import * as path from 'path';
+
+/**
+ * RunTestsToolV2 - Enhanced test runner with better output
+ */
+export class RunTestsToolV2 extends Tool<
+  { command?: string; cwd?: string; timeout?: number },
+  { success: boolean; output: string; exitCode: number; duration: number }
+> {
+  private defaultCwd: string;
+
+  constructor(defaultCwd: string = process.cwd()) {
+    super();
+    this.defaultCwd = path.resolve(defaultCwd);
+  }
+
+  name(): string {
+    return 'run_tests_v2';
+  }
+
+  async call(input: {
+    command?: string;
+    cwd?: string;
+    timeout?: number;
+  }): Promise<{ success: boolean; output: string; exitCode: number; duration: number }> {
+    const { execa } = await import('execa');
+    const command = input.command || 'npm test';
+    const timeout = input.timeout ?? 300000; // 5 minutes
+
+    const startTime = Date.now();
+
+    const resolvedCwd = this.resolveCwd(input.cwd);
+
+    try {
+      const result = await execa(command, {
+        shell: true,
+        cwd: resolvedCwd,
+        timeout,
+      });
+
+      return {
+        success: result.exitCode === 0,
+        output: result.stdout + '\n' + result.stderr,
+        exitCode: result.exitCode || 0,
+        duration: Date.now() - startTime,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        output: (error.stdout || '') + '\n' + (error.stderr || ''),
+        exitCode: error.exitCode || 1,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  private resolveCwd(cwd?: string): string {
+    if (!cwd) {
+      return this.defaultCwd;
+    }
+
+    return path.isAbsolute(cwd) ? cwd : path.resolve(this.defaultCwd, cwd);
+  }
+}
+
+/**
+ * BuildTool - Run build commands with error extraction
+ */
+export class BuildTool extends Tool<
+  { command?: string; cwd?: string; timeout?: number },
+  { success: boolean; output: string; errors: string[]; duration: number }
+> {
+  private defaultCwd: string;
+
+  constructor(defaultCwd: string = process.cwd()) {
+    super();
+    this.defaultCwd = path.resolve(defaultCwd);
+  }
+
+  name(): string {
+    return 'build';
+  }
+
+  async call(input: {
+    command?: string;
+    cwd?: string;
+    timeout?: number;
+  }): Promise<{ success: boolean; output: string; errors: string[]; duration: number }> {
+    const { execa } = await import('execa');
+    const command = input.command || 'npm run build';
+    const timeout = input.timeout ?? 600000; // 10 minutes
+
+    const startTime = Date.now();
+
+    const resolvedCwd = this.resolveCwd(input.cwd);
+
+    try {
+      const result = await execa(command, {
+        shell: true,
+        cwd: resolvedCwd,
+        timeout,
+      });
+
+      return {
+        success: result.exitCode === 0,
+        output: result.stdout + '\n' + result.stderr,
+        errors: [],
+        duration: Date.now() - startTime,
+      };
+    } catch (error: any) {
+      const output = (error.stdout || '') + '\n' + (error.stderr || '');
+      
+      // Extract errors (simple pattern matching)
+      const errors = this.extractErrors(output);
+
+      return {
+        success: false,
+        output,
+        errors,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  private extractErrors(output: string): string[] {
+    const errors: string[] = [];
+    const lines = output.split('\n');
+
+    for (const line of lines) {
+      if (line.includes('error') || line.includes('Error:') || line.includes('ERROR')) {
+        errors.push(line.trim());
+      }
+    }
+
+    return errors.slice(0, 20); // Limit to first 20 errors
+  }
+
+  private resolveCwd(cwd?: string): string {
+    if (!cwd) {
+      return this.defaultCwd;
+    }
+
+    return path.isAbsolute(cwd) ? cwd : path.resolve(this.defaultCwd, cwd);
+  }
+}