@ddse/acm-aicoder 0.5.0

package/src/context/symbol-extractor.ts

@@ -0,0 +1,149 @@
+// 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

@@ -0,0 +1,77 @@
+// 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

@@ -0,0 +1,69 @@
+// 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;
+}

package/src/context/workspace-indexer.ts

@@ -0,0 +1,249 @@
+// Workspace Indexer - Fast file scanning and caching
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import type { FileMetadata, WorkspaceIndex } from './types.js';
+
+const DEFAULT_IGNORES = [
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.cache',
+  'coverage',
+  '.aicoder',
+  '*.lock',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+];
+
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico',
+  '.pdf', '.zip', '.tar', '.gz', '.bz2',
+  '.exe', '.dll', '.so', '.dylib',
+  '.woff', '.woff2', '.ttf', '.eot',
+  '.mp4', '.mp3', '.wav', '.avi',
+]);
+
+const LANGUAGE_MAP: Record<string, string> = {
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.mjs': 'javascript',
+  '.cjs': 'javascript',
+  '.py': 'python',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.java': 'java',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.md': 'markdown',
+  '.json': 'json',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.toml': 'toml',
+  '.xml': 'xml',
+  '.html': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.sql': 'sql',
+  '.sh': 'shell',
+};
+
+export class WorkspaceIndexer {
+  private rootPath: string;
+  private ignorePatterns: Set<string>;
+  private cacheDir: string;
+
+  constructor(rootPath: string, additionalIgnores: string[] = []) {
+    this.rootPath = path.resolve(rootPath);
+    this.ignorePatterns = new Set([...DEFAULT_IGNORES, ...additionalIgnores]);
+    this.cacheDir = path.join(this.rootPath, '.aicoder');
+  }
+
+  /**
+   * Build or refresh the workspace index
+   */
+  async buildIndex(options: { useCache?: boolean; maxFileSize?: number } = {}): Promise<WorkspaceIndex> {
+    const useCache = options.useCache ?? true;
+    const maxFileSize = options.maxFileSize ?? 1_000_000; // 1MB default
+
+    // Try to load from cache
+    if (useCache) {
+      const cached = await this.loadCache();
+      if (cached) {
+        return cached;
+      }
+    }
+
+    // Scan workspace
+    const files: FileMetadata[] = [];
+    await this.scanDirectory(this.rootPath, files, maxFileSize);
+
+    const index: WorkspaceIndex = {
+      files,
+      totalFiles: files.length,
+      totalSize: files.reduce((sum, f) => sum + f.size, 0),
+      indexedAt: new Date().toISOString(),
+      rootPath: this.rootPath,
+    };
+
+    // Save to cache
+    if (useCache) {
+      await this.saveCache(index);
+    }
+
+    return index;
+  }
+
+  /**
+   * Recursively scan directory for files
+   */
+  private async scanDirectory(
+    dirPath: string,
+    files: FileMetadata[],
+    maxFileSize: number
+  ): Promise<void> {
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const relativePath = path.relative(this.rootPath, fullPath);
+
+        // Skip ignored patterns
+        if (this.shouldIgnore(relativePath, entry.name)) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          await this.scanDirectory(fullPath, files, maxFileSize);
+        } else if (entry.isFile()) {
+          try {
+            const stats = await fs.stat(fullPath);
+            
+            // Skip files that are too large
+            if (stats.size > maxFileSize) {
+              continue;
+            }
+
+            const ext = path.extname(entry.name);
+            const isBinary = BINARY_EXTENSIONS.has(ext);
+            
+            // Compute hash for non-binary files
+            let hash = '';
+            if (!isBinary && stats.size < 100_000) { // Hash only small text files
+              try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                hash = createHash('sha256').update(content).digest('hex').substring(0, 16);
+              } catch {
+                // Skip files that can't be read
+                continue;
+              }
+            }
+
+            files.push({
+              path: relativePath,
+              size: stats.size,
+              mtime: stats.mtimeMs,
+              hash,
+              language: LANGUAGE_MAP[ext] || 'unknown',
+              isBinary,
+            });
+          } catch (error) {
+            // Skip files we can't stat
+            continue;
+          }
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read
+    }
+  }
+
+  /**
+   * Check if path should be ignored
+   */
+  private shouldIgnore(relativePath: string, name: string): boolean {
+    // Check exact matches
+    if (this.ignorePatterns.has(name)) {
+      return true;
+    }
+
+    // Check if any part of the path matches ignore patterns
+    const parts = relativePath.split(path.sep);
+    for (const part of parts) {
+      if (this.ignorePatterns.has(part)) {
+        return true;
+      }
+    }
+
+    // Check wildcard patterns
+    for (const pattern of this.ignorePatterns) {
+      if (pattern.includes('*')) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        if (regex.test(name)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Load index from cache
+   */
+  private async loadCache(): Promise<WorkspaceIndex | null> {
+    try {
+      const cachePath = path.join(this.cacheDir, 'index.json');
+      const content = await fs.readFile(cachePath, 'utf-8');
+      const index: WorkspaceIndex = JSON.parse(content);
+
+      // Validate cache is recent (within 1 hour)
+      const cacheAge = Date.now() - new Date(index.indexedAt).getTime();
+      if (cacheAge > 3600_000) {
+        return null;
+      }
+
+      return index;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save index to cache
+   */
+  private async saveCache(index: WorkspaceIndex): Promise<void> {
+    try {
+      await fs.mkdir(this.cacheDir, { recursive: true });
+      const cachePath = path.join(this.cacheDir, 'index.json');
+      await fs.writeFile(cachePath, JSON.stringify(index, null, 2), 'utf-8');
+    } catch {
+      // Cache save is best-effort
+    }
+  }
+
+  /**
+   * Get files by language
+   */
+  static filterByLanguage(index: WorkspaceIndex, languages: string[]): FileMetadata[] {
+    const langSet = new Set(languages);
+    return index.files.filter(f => langSet.has(f.language));
+  }
+
+  /**
+   * Get recently modified files
+   */
+  static getRecentFiles(index: WorkspaceIndex, count: number = 10): FileMetadata[] {
+    return [...index.files]
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, count);
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+// ACM AI Coder - Phase 2 exports
+export * from './tools-v2/index.js';
+export * from './tasks-v2/index.js';
+export * from './registries.js';
+export * from './context/index.js';

package/src/registries.ts

@@ -0,0 +1,118 @@
+// Registries and Policy for AI Coder
+import { 
+  CapabilityRegistry,
+  ToolRegistry,
+  PolicyEngine,
+  type Capability, 
+  type Tool, 
+  type Task,
+  type PolicyDecision,
+} from '@ddse/acm-sdk';
+
+/**
+ * Simple Capability Registry
+ */
+export class SimpleCapabilityRegistry extends CapabilityRegistry {
+  private tasks = new Map<string, Task>();
+  private capabilities = new Map<string, Capability>();
+
+  register(capability: Capability, task: Task): void {
+    this.capabilities.set(capability.name, capability);
+    this.tasks.set(capability.name, task);
+  }
+
+  list(): Capability[] {
+    return Array.from(this.capabilities.values());
+  }
+
+  has(name: string): boolean {
+    return this.capabilities.has(name);
+  }
+
+  resolve(name: string): Task | undefined {
+    return this.tasks.get(name);
+  }
+
+  inputSchema(name: string): unknown | undefined {
+    return this.capabilities.get(name)?.inputSchema;
+  }
+
+  outputSchema(name: string): unknown | undefined {
+    return this.capabilities.get(name)?.outputSchema;
+  }
+}
+
+/**
+ * Simple Tool Registry
+ */
+export class SimpleToolRegistry extends ToolRegistry {
+  private tools = new Map<string, Tool>();
+
+  register(tool: Tool): void {
+    this.tools.set(tool.name(), tool);
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  list(): string[] {
+    return Array.from(this.tools.keys());
+  }
+}
+
+/**
+ * Simple Policy Engine with safety rules for code modifications
+ */
+export class SimplePolicyEngine implements PolicyEngine {
+  private allowedPaths: string[] = [];
+  private blockedActions: string[] = [];
+
+  setAllowedPaths(paths: string[]): void {
+    this.allowedPaths = paths;
+  }
+
+  setBlockedActions(actions: string[]): void {
+    this.blockedActions = actions;
+  }
+
+  async evaluate(
+    action: 'plan.admit' | 'task.pre' | 'task.post',
+    payload: any
+  ): Promise<PolicyDecision> {
+    // Check if action is blocked
+    if (action === 'task.pre' && this.blockedActions.includes(payload?.action)) {
+      return {
+        allow: false,
+        reason: `Action ${payload?.action} is blocked by policy`,
+      };
+    }
+
+    // For code editing operations, check path is allowed
+    if (action === 'task.pre' && (payload?.action === 'fix_bug' || payload?.action === 'implement_feature')) {
+      const targetPath = payload?.path || payload?.targetPath;
+      
+      if (this.allowedPaths.length > 0 && targetPath && !this.allowedPaths.includes('*')) {
+        const isAllowed = this.allowedPaths.some(allowed => 
+          targetPath.includes(allowed)
+        );
+        
+        if (!isAllowed) {
+          return {
+            allow: false,
+            reason: `Path ${targetPath} is not in allowed paths`,
+          };
+        }
+      }
+    }
+
+    // Default: allow
+    return {
+      allow: true,
+      limits: {
+        timeoutMs: 30000,
+        retries: 3,
+      },
+    };
+  }
+}