@ddse/acm-aicoder 0.5.0 → 0.5.1

package/src/context/workspace-indexer.ts

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

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

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

package/src/runtime/budget-manager.ts

@@ -1,118 +0,0 @@
-// Token budget manager
-// Tracks cumulative token usage and ensures calls stay within provider limits
-
-import {
-  ProviderMetadata,
-  getProviderMetadata,
-  estimateTokenCount,
-} from '../config/providers.js';
-
-export interface BudgetEstimate {
-  inputTokens: number;
-  outputTokens: number;
-  totalTokens: number;
-}
-
-export interface BudgetStatus {
-  totalInputTokens: number;
-  totalOutputTokens: number;
-  totalTokens: number;
-  maxTokens?: number;
-  remainingTokens?: number;
-  callCount: number;
-}
-
-export class BudgetManager {
-  private metadata: ProviderMetadata;
-  private maxTokens?: number;
-  private totalInputTokens = 0;
-  private totalOutputTokens = 0;
-  private callCount = 0;
-
-  constructor(model: string, overrideMaxTokens?: number) {
-    this.metadata = getProviderMetadata(model);
-    this.maxTokens = overrideMaxTokens ?? this.metadata.maxContextTokens;
-  }
-
-  /**
-   * Estimate whether an upcoming inference fits within the token allowance
-   * @param inputText Planned prompt text
-   * @param estimatedOutputTokens Rough guess for completion tokens
-   */
-  checkBudget(inputText: string, estimatedOutputTokens: number = 1000): BudgetEstimate {
-    const inputTokens = estimateTokenCount(inputText);
-    const totalTokens = inputTokens + estimatedOutputTokens;
-
-    if (this.maxTokens !== undefined) {
-      const projected = this.totalTokensConsumed() + totalTokens;
-      if (projected > this.maxTokens) {
-        throw new TokenBudgetExceededError(
-          `Token allowance exceeded: projected ${projected} tokens > limit ${this.maxTokens}`,
-          {
-            inputTokens,
-            outputTokens: estimatedOutputTokens,
-            totalTokens,
-          },
-          this.getStatus()
-        );
-      }
-    }
-
-    return {
-      inputTokens,
-      outputTokens: estimatedOutputTokens,
-      totalTokens,
-    };
-  }
-
-  /**
-   * Record actual token usage after a call completes
-   */
-  recordUsage(actualInputTokens: number, actualOutputTokens: number): void {
-    this.totalInputTokens += actualInputTokens;
-    this.totalOutputTokens += actualOutputTokens;
-    this.callCount += 1;
-  }
-
-  getStatus(): BudgetStatus {
-    const totalTokens = this.totalTokensConsumed();
-    const status: BudgetStatus = {
-      totalInputTokens: this.totalInputTokens,
-      totalOutputTokens: this.totalOutputTokens,
-      totalTokens,
-      maxTokens: this.maxTokens,
-      callCount: this.callCount,
-    };
-
-    if (this.maxTokens !== undefined) {
-      status.remainingTokens = Math.max(0, this.maxTokens - totalTokens);
-    }
-
-    return status;
-  }
-
-  getMetadata(): ProviderMetadata {
-    return this.metadata;
-  }
-
-  reset(): void {
-    this.totalInputTokens = 0;
-    this.totalOutputTokens = 0;
-    this.callCount = 0;
-  }
-
-  private totalTokensConsumed(): number {
-    return this.totalInputTokens + this.totalOutputTokens;
-  }
-}
-
-export class TokenBudgetExceededError extends Error {
-  constructor(
-    message: string,
-    public estimate: BudgetEstimate,
-    public status: BudgetStatus
-  ) {
-    super(message);
-    this.name = 'TokenBudgetExceededError';
-  }
-}