@ddse/acm-aicoder 0.5.0 → 0.5.2

package/src/config/providers.ts

@@ -1,174 +0,0 @@
-// Provider metadata for budget governance
-// Token costs and context limits per model/provider
-
-export interface ProviderMetadata {
-  provider: string;
-  model: string;
-  
-  // Cost per 1M tokens (USD)
-  inputCostPer1M?: number;
-  outputCostPer1M?: number;
-  
-  // Context window
-  maxContextTokens?: number;
-  
-  // Concurrency limits
-  maxConcurrentRequests?: number;
-  
-  // Recommended settings
-  recommendedTemperature?: number;
-  supportsStreaming: boolean;
-}
-
-// Provider metadata registry
-// Sources: OpenAI pricing, Anthropic pricing, Azure OpenAI, local models
-export const PROVIDER_METADATA: Record<string, ProviderMetadata> = {
-  // OpenAI models
-  'gpt-4o': {
-    provider: 'openai',
-    model: 'gpt-4o',
-    inputCostPer1M: 2.50,
-    outputCostPer1M: 10.00,
-    maxContextTokens: 128000,
-    maxConcurrentRequests: 10,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'gpt-4o-mini': {
-    provider: 'openai',
-    model: 'gpt-4o-mini',
-    inputCostPer1M: 0.15,
-    outputCostPer1M: 0.60,
-    maxContextTokens: 128000,
-    maxConcurrentRequests: 10,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'gpt-4-turbo': {
-    provider: 'openai',
-    model: 'gpt-4-turbo',
-    inputCostPer1M: 10.00,
-    outputCostPer1M: 30.00,
-    maxContextTokens: 128000,
-    maxConcurrentRequests: 10,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'gpt-3.5-turbo': {
-    provider: 'openai',
-    model: 'gpt-3.5-turbo',
-    inputCostPer1M: 0.50,
-    outputCostPer1M: 1.50,
-    maxContextTokens: 16385,
-    maxConcurrentRequests: 10,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  
-  // Anthropic models
-  'claude-3-opus-20240229': {
-    provider: 'anthropic',
-    model: 'claude-3-opus-20240229',
-    inputCostPer1M: 15.00,
-    outputCostPer1M: 75.00,
-    maxContextTokens: 200000,
-    maxConcurrentRequests: 5,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'claude-3-sonnet-20240229': {
-    provider: 'anthropic',
-    model: 'claude-3-sonnet-20240229',
-    inputCostPer1M: 3.00,
-    outputCostPer1M: 15.00,
-    maxContextTokens: 200000,
-    maxConcurrentRequests: 5,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'claude-3-haiku-20240307': {
-    provider: 'anthropic',
-    model: 'claude-3-haiku-20240307',
-    inputCostPer1M: 0.25,
-    outputCostPer1M: 1.25,
-    maxContextTokens: 200000,
-    maxConcurrentRequests: 5,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  
-  // Local/self-hosted models (no cost)
-  'llama3.1': {
-    provider: 'ollama',
-    model: 'llama3.1',
-    inputCostPer1M: 0,
-    outputCostPer1M: 0,
-    maxContextTokens: 128000,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'qwen2.5:7b': {
-    provider: 'ollama',
-    model: 'qwen2.5:7b',
-    inputCostPer1M: 0,
-    outputCostPer1M: 0,
-    maxContextTokens: 32768,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-  'deepseek-coder': {
-    provider: 'ollama',
-    model: 'deepseek-coder',
-    inputCostPer1M: 0,
-    outputCostPer1M: 0,
-    maxContextTokens: 16000,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  },
-};
-
-export function getProviderMetadata(model: string): ProviderMetadata {
-  // Try exact match first
-  if (PROVIDER_METADATA[model]) {
-    return PROVIDER_METADATA[model];
-  }
-  
-  // Try prefix match (e.g., "gpt-4o-2024-05-13" matches "gpt-4o")
-  for (const [key, metadata] of Object.entries(PROVIDER_METADATA)) {
-    if (model.startsWith(key)) {
-      return metadata;
-    }
-  }
-  
-  // Default metadata for unknown models (assume local/free)
-  return {
-    provider: 'unknown',
-    model,
-    inputCostPer1M: 0,
-    outputCostPer1M: 0,
-    maxContextTokens: 8192,
-    recommendedTemperature: 0.7,
-    supportsStreaming: true,
-  };
-}
-
-export function estimateTokenCount(text: string): number {
-  // Rough approximation: 1 token ≈ 4 characters for English text
-  // More accurate would use tiktoken library, but this is sufficient for budget estimation
-  return Math.ceil(text.length / 4);
-}
-
-export function estimateCost(
-  inputTokens: number,
-  outputTokens: number,
-  metadata: ProviderMetadata
-): number {
-  if (!metadata.inputCostPer1M || !metadata.outputCostPer1M) {
-    return 0;
-  }
-  
-  const inputCost = (inputTokens / 1_000_000) * metadata.inputCostPer1M;
-  const outputCost = (outputTokens / 1_000_000) * metadata.outputCostPer1M;
-  
-  return inputCost + outputCost;
-}

package/src/config/session.ts

@@ -1,143 +0,0 @@
-// Session configuration for AI Coder Phase 2
-// Manages CLI arguments and session metadata using provider/model semantics
-
-import { existsSync, statSync } from 'fs';
-import path from 'path';
-import os from 'os';
-
-export type Provider = 'ollama' | 'vllm';
-
-export interface SessionConfig {
-  provider: Provider;
-  model: string;
-  baseUrl?: string;
-  workspace: string;
-  temperature: number;
-  seed?: number;
-  planCount: 1 | 2;
-  sessionId: string;
-  timestamp: number;
-}
-
-export interface CLIArgs {
-  provider?: string;
-  model?: string;
-  'base-url'?: string;
-  workspace?: string;
-  temperature?: string;
-  seed?: string;
-  plans?: string;
-  [key: string]: string | undefined;
-}
-
-export function parseCliArgs(argv: string[]): CLIArgs {
-  const args: CLIArgs = {};
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith('--')) {
-      // Support --key=value form
-      if (arg.includes('=')) {
-        const pair = arg.slice(2);
-        const eqIndex = pair.indexOf('=');
-        const key = pair.slice(0, eqIndex);
-        const value = pair.slice(eqIndex + 1);
-        if (key.length > 0) {
-          args[key] = value;
-        }
-        continue;
-      }
-
-      // Support space-separated --key value form
-      const key = arg.slice(2);
-      const value = argv[i + 1];
-      if (value && !value.startsWith('--')) {
-        args[key] = value;
-        i++;
-      }
-    }
-  }
-
-  return args;
-}
-
-export function validateAndNormalizeConfig(args: CLIArgs): SessionConfig {
-  const provider = (args.provider as Provider) || 'ollama';
-  if (!['ollama', 'vllm'].includes(provider)) {
-    throw new Error(`Invalid --provider: ${args.provider}. Must be "ollama" or "vllm".`);
-  }
-
-  const model = args.model || (provider === 'ollama' ? 'llama3.1' : undefined);
-  const missing: string[] = [];
-
-  if (!model) missing.push('--model');
-  if (!args.workspace || args.workspace.trim().length === 0) missing.push('--workspace');
-
-  if (missing.length > 0) {
-    throw new Error(
-      `Missing required parameters: ${missing.join(', ')}\n\n` +
-      `ACM AI Coder requires these parameters to start:\n` +
-      `  --provider <ollama|vllm>  LLM provider (default: ollama)\n` +
-      `  --model <name>            Model identifier (e.g., llama3.1, gpt-4o)\n` +
-      `  --workspace <path>        REQUIRED: absolute or relative path to project root\n\n` +
-      `Optional parameters:\n` +
-      `  --base-url <url>          Override provider base URL\n` +
-      `  --temperature <0-2>       LLM temperature (default: 0.7)\n` +
-      `  --seed <number>           Random seed for reproducibility\n` +
-      `  --plans <1|2>             Number of alternative plans (default: 1)\n\n` +
-      `Examples:\n` +
-      `  acm-aicoder --provider vllm --model gpt-4o --workspace /abs/path\n` +
-      `  acm-aicoder --provider ollama --model llama3.1 --workspace=~/myproject`
-    );
-  }
-
-  const temperature = args.temperature ? parseFloat(args.temperature) : 0.7;
-  if (isNaN(temperature) || temperature < 0 || temperature > 2) {
-    throw new Error(`Invalid --temperature: must be between 0 and 2`);
-  }
-
-  const seed = args.seed ? parseInt(args.seed, 10) : undefined;
-  if (seed !== undefined && Number.isNaN(seed)) {
-    throw new Error(`Invalid --seed: must be a number`);
-  }
-
-  const planCount = args.plans === '2' ? 2 : 1;
-
-  // Enforce explicit workspace and normalize
-  const baseCwd = process.env.INIT_CWD || process.env.PWD || process.cwd();
-  let workspaceInput = args.workspace!;
-
-  // Expand ~ to user home
-  if (workspaceInput.startsWith('~/')) {
-    workspaceInput = path.join(os.homedir(), workspaceInput.slice(2));
-  }
-
-  const resolvedWorkspace = path.isAbsolute(workspaceInput)
-    ? workspaceInput
-    : path.resolve(baseCwd, workspaceInput);
-
-  if (!existsSync(resolvedWorkspace)) {
-    throw new Error(
-      `Workspace path "${resolvedWorkspace}" does not exist. Please provide a valid --workspace.`
-    );
-  }
-
-  const stats = statSync(resolvedWorkspace);
-  if (!stats.isDirectory()) {
-    throw new Error(
-      `Workspace path "${resolvedWorkspace}" is not a directory. Please provide a valid --workspace.`
-    );
-  }
-
-  return {
-    provider,
-    model: model!,
-    baseUrl: args['base-url'],
-    workspace: resolvedWorkspace,
-    temperature,
-    seed,
-    planCount,
-    sessionId: `session-${Date.now()}`,
-    timestamp: Date.now(),
-  };
-}

package/src/context/bm25.ts

@@ -1,173 +0,0 @@
-// Simple BM25 search implementation for ACM examples
-
-/**
- * Document interface for BM25 search
- */
-export interface Document {
-  id: string;
-  title?: string;
-  content: string;
-  [key: string]: any;
-}
-
-/**
- * Search result with score
- */
-export interface SearchResult {
-  document: Document;
-  score: number;
-}
-
-/**
- * BM25 parameters
- */
-export interface BM25Params {
-  k1?: number; // Term frequency saturation (default: 1.5)
-  b?: number;  // Length normalization (default: 0.75)
-}
-
-/**
- * Simple tokenizer
- */
-function tokenize(text?: string | null): string[] {
-  if (!text) return [];
-
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s]/g, ' ')
-    .split(/\s+/)
-    .filter((token) => token.length > 0);
-}
-
-/**
- * BM25 Search Engine
- * 
- * Implements the BM25 ranking function for full-text search.
- * BM25 is a probabilistic ranking function used by search engines
- * to estimate the relevance of documents to a query.
- */
-export class BM25Search {
-  private documents: Document[] = [];
-  private documentTokens: Map<string, string[]> = new Map();
-  private documentFrequency: Map<string, number> = new Map();
-  private averageDocumentLength: number = 0;
-  private k1: number;
-  private b: number;
-
-  constructor(params: BM25Params = {}) {
-    this.k1 = params.k1 ?? 1.5;
-    this.b = params.b ?? 0.75;
-  }
-
-  /**
-   * Index documents for search
-   */
-  index(documents: Document[]): void {
-    this.documents = documents;
-    this.documentTokens.clear();
-    this.documentFrequency.clear();
-
-    // Tokenize documents
-    let totalLength = 0;
-    for (const doc of documents) {
-      const text = this.extractText(doc);
-      const tokens = tokenize(text);
-      this.documentTokens.set(doc.id, tokens);
-      totalLength += tokens.length;
-
-      // Update document frequency
-      const uniqueTokens = new Set(tokens);
-      for (const token of uniqueTokens) {
-        this.documentFrequency.set(token, (this.documentFrequency.get(token) || 0) + 1);
-      }
-    }
-
-    this.averageDocumentLength = totalLength / documents.length;
-  }
-
-  /**
-   * Extract searchable text from document
-   */
-  private extractText(doc: Document): string {
-    const parts: string[] = [];
-    if (doc.title) parts.push(doc.title);
-    if (doc.content) parts.push(doc.content);
-    return parts.join(' ');
-  }
-
-  /**
-   * Calculate IDF (Inverse Document Frequency)
-   */
-  private idf(term: string): number {
-    const df = this.documentFrequency.get(term) || 0;
-    if (df === 0) return 0;
-
-    const n = this.documents.length;
-    return Math.log((n - df + 0.5) / (df + 0.5) + 1);
-  }
-
-  /**
-   * Calculate BM25 score for a document
-   */
-  private score(docId: string, queryTokens: string[]): number {
-    const tokens = this.documentTokens.get(docId);
-    if (!tokens) return 0;
-
-    const docLength = tokens.length;
-    let score = 0;
-
-    for (const queryToken of queryTokens) {
-      const termFreq = tokens.filter((t) => t === queryToken).length;
-      if (termFreq === 0) continue;
-
-      const idf = this.idf(queryToken);
-      const numerator = termFreq * (this.k1 + 1);
-      const denominator = termFreq + this.k1 * (1 - this.b + this.b * (docLength / this.averageDocumentLength));
-
-      score += idf * (numerator / denominator);
-    }
-
-    return score;
-  }
-
-  /**
-   * Search for documents matching the query
-   */
-  search(query: string, limit: number = 10): SearchResult[] {
-    if (this.documents.length === 0) {
-      return [];
-    }
-
-    const queryTokens = tokenize(query);
-    if (queryTokens.length === 0) {
-      return [];
-    }
-
-    // Score all documents
-    const results: SearchResult[] = [];
-    for (const doc of this.documents) {
-      const score = this.score(doc.id, queryTokens);
-      if (score > 0) {
-        results.push({ document: doc, score });
-      }
-    }
-
-    // Sort by score (descending) and limit
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
-  }
-
-  /**
-   * Get all indexed documents
-   */
-  getDocuments(): Document[] {
-    return this.documents;
-  }
-
-  /**
-   * Get document count
-   */
-  getDocumentCount(): number {
-    return this.documents.length;
-  }
-}

package/src/context/code-search.ts

@@ -1,188 +0,0 @@
-// Code Search - BM25 based search for code files
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { BM25Search, type Document } from './bm25.js';
-import type { WorkspaceIndex, FileMetadata, SearchResult } from './types.js';
-
-export interface SearchOptions {
-  k?: number; // Number of results
-  preferTypes?: string[]; // Prefer certain file types
-  includeContext?: boolean; // Include surrounding lines
-  contextLines?: number; // Number of context lines
-}
-
-export class CodeSearch {
-  private bm25: BM25Search;
-  private rootPath: string;
-  private documents: Map<string, Document> = new Map();
-
-  constructor(rootPath: string) {
-    this.rootPath = rootPath;
-    this.bm25 = new BM25Search({ k1: 1.5, b: 0.75 });
-  }
-
-  /**
-   * Index files for search
-   */
-  async indexFiles(index: WorkspaceIndex): Promise<void> {
-    const documents: Document[] = [];
-    this.documents.clear();
-
-    // Filter to text files only
-    const textFiles = index.files.filter(f => 
-      !f.isBinary && 
-      f.size < 500_000 && // Only index files < 500KB
-      (f.language === 'typescript' || 
-       f.language === 'javascript' || 
-       f.language === 'markdown' ||
-       f.language === 'json')
-    );
-
-    // Read and index each file
-    for (const file of textFiles) {
-      try {
-        const fullPath = path.join(this.rootPath, file.path);
-        const content = await fs.readFile(fullPath, 'utf-8');
-        
-        const doc: Document = {
-          id: file.path,
-          title: path.basename(file.path),
-          content,
-          language: file.language,
-          size: file.size,
-          path: file.path,
-        };
-
-        documents.push(doc);
-        this.documents.set(file.path, doc);
-      } catch {
-        // Skip files we can't read
-      }
-    }
-
-    // Build BM25 index
-    this.bm25.index(documents);
-  }
-
-  /**
-   * Search for code
-   */
-  async search(query: string, options: SearchOptions = {}): Promise<SearchResult[]> {
-    const k = options.k ?? 10;
-    const preferTypes = new Set(options.preferTypes || []);
-
-    // Search using BM25
-    const bm25Results = this.bm25.search(query, k * 2); // Get more initially
-
-    // Apply preferences and convert to SearchResult
-    const results: SearchResult[] = [];
-
-    for (const result of bm25Results) {
-      const doc = result.document;
-      let score = result.score;
-
-      // Boost score for preferred file types
-      if (preferTypes.size > 0) {
-        const ext = path.extname(doc.path);
-        const lang = doc.language as string;
-        if (preferTypes.has(ext) || preferTypes.has(lang)) {
-          score *= 1.5;
-        }
-      }
-
-      // Find best matching line
-      const snippet = this.findBestSnippet(doc.content, query, options);
-
-      results.push({
-        path: doc.path,
-        score,
-        snippet: snippet.text,
-        line: snippet.line,
-        column: snippet.column,
-      });
-    }
-
-    // Re-sort by adjusted scores and limit
-    return results
-      .sort((a, b) => b.score - a.score)
-      .slice(0, k);
-  }
-
-  /**
-   * Find the best snippet matching the query
-   */
-  private findBestSnippet(
-    content: string, 
-    query: string,
-    options: SearchOptions
-  ): { text: string; line: number; column: number } {
-    const lines = content.split('\n');
-    const queryLower = query.toLowerCase();
-    const queryTokens = queryLower.split(/\s+/);
-
-    let bestLine = 0;
-    let bestScore = 0;
-
-    // Find line with most query tokens
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const lineLower = line.toLowerCase();
-      
-      let score = 0;
-      for (const token of queryTokens) {
-        if (lineLower.includes(token)) {
-          score += 1;
-        }
-      }
-
-      if (score > bestScore) {
-        bestScore = score;
-        bestLine = i;
-      }
-    }
-
-    // Extract snippet with context
-    const contextLines = options.includeContext ? (options.contextLines ?? 2) : 0;
-    const startLine = Math.max(0, bestLine - contextLines);
-    const endLine = Math.min(lines.length - 1, bestLine + contextLines);
-
-    const snippetLines = lines.slice(startLine, endLine + 1);
-    const snippet = snippetLines
-      .map((line, idx) => {
-        const lineNum = startLine + idx + 1;
-        const marker = lineNum === bestLine + 1 ? '>' : ' ';
-        return `${marker} ${lineNum.toString().padStart(4, ' ')} ${line}`;
-      })
-      .join('\n');
-
-    // Find column position (first occurrence of any query token)
-    let column = 0;
-    const bestLineLower = lines[bestLine].toLowerCase();
-    for (const token of queryTokens) {
-      const pos = bestLineLower.indexOf(token);
-      if (pos >= 0) {
-        column = pos;
-        break;
-      }
-    }
-
-    return {
-      text: snippet,
-      line: bestLine + 1,
-      column,
-    };
-  }
-
-  /**
-   * Search for symbol by name (exact or partial match)
-   */
-  async searchSymbol(symbolName: string): Promise<SearchResult[]> {
-    // Search for exact symbol name with high weight
-    return this.search(`${symbolName} function class interface`, {
-      k: 5,
-      preferTypes: ['.ts', '.tsx', '.js', '.jsx'],
-      includeContext: true,
-      contextLines: 3,
-    });
-  }
-}