@cogitator-ai/self-modifying 0.1.0

package/src/architecture-evolution/capability-analyzer.ts

@@ -0,0 +1,337 @@
+import type { Tool, LLMBackend, TaskProfile } from '@cogitator-ai/types';
+import { buildTaskProfilePrompt, parseTaskProfileResponse } from './prompts';
+
+export interface CapabilityAnalyzerOptions {
+  llm?: LLMBackend;
+  enableLLMAnalysis?: boolean;
+}
+
+interface DomainKeywords {
+  coding: string[];
+  reasoning: string[];
+  creative: string[];
+  factual: string[];
+  conversational: string[];
+}
+
+const DOMAIN_KEYWORDS: DomainKeywords = {
+  coding: [
+    'code', 'program', 'function', 'class', 'debug', 'implement', 'refactor',
+    'typescript', 'javascript', 'python', 'api', 'database', 'sql', 'algorithm',
+    'data structure', 'compile', 'syntax', 'bug', 'error', 'test', 'unit test',
+  ],
+  reasoning: [
+    'analyze', 'reason', 'logic', 'deduce', 'infer', 'solve', 'problem',
+    'strategy', 'plan', 'decision', 'evaluate', 'compare', 'trade-off',
+    'optimize', 'proof', 'argument', 'conclusion', 'hypothesis',
+  ],
+  creative: [
+    'create', 'imagine', 'story', 'poem', 'write', 'design', 'brainstorm',
+    'innovative', 'novel', 'artistic', 'compose', 'invent', 'original',
+    'creative', 'fiction', 'narrative', 'metaphor', 'style',
+  ],
+  factual: [
+    'what is', 'define', 'explain', 'describe', 'list', 'fact', 'information',
+    'history', 'science', 'data', 'statistic', 'research', 'study', 'source',
+    'reference', 'accurate', 'true', 'correct',
+  ],
+  conversational: [
+    'chat', 'talk', 'hello', 'hi', 'thanks', 'please', 'help', 'assist',
+    'question', 'answer', 'discuss', 'conversation', 'opinion',
+  ],
+};
+
+const COMPLEXITY_INDICATORS = {
+  trivial: ['simple', 'quick', 'easy', 'basic', 'straightforward'],
+  simple: ['explain', 'define', 'list', 'describe', 'show'],
+  moderate: ['compare', 'analyze', 'summarize', 'evaluate', 'implement'],
+  complex: ['design', 'architect', 'optimize', 'comprehensive', 'detailed'],
+  extreme: ['novel', 'research', 'breakthrough', 'state-of-the-art', 'cutting-edge'],
+};
+
+export class CapabilityAnalyzer {
+  private readonly llm?: LLMBackend;
+  private readonly enableLLMAnalysis: boolean;
+  private readonly profileCache = new Map<string, { profile: TaskProfile; timestamp: number }>();
+  private readonly cacheTTL = 60000;
+
+  constructor(options: CapabilityAnalyzerOptions = {}) {
+    this.llm = options.llm;
+    this.enableLLMAnalysis = options.enableLLMAnalysis ?? false;
+  }
+
+  async analyzeTask(
+    taskDescription: string,
+    context?: {
+      availableTools?: Tool[];
+      previousTasks?: string[];
+      constraints?: { maxCost?: number; maxLatency?: number };
+    }
+  ): Promise<TaskProfile> {
+    const cacheKey = this.buildCacheKey(taskDescription);
+    const cached = this.profileCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+      return cached.profile;
+    }
+
+    let profile: TaskProfile;
+
+    if (this.llm && this.enableLLMAnalysis) {
+      profile = await this.analyzWithLLM(taskDescription, context);
+    } else {
+      profile = this.analyzeHeuristically(taskDescription, context?.availableTools);
+    }
+
+    this.profileCache.set(cacheKey, { profile, timestamp: Date.now() });
+
+    if (this.profileCache.size > 100) {
+      const entries = Array.from(this.profileCache.entries());
+      entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+      entries.slice(0, 20).forEach(([key]) => this.profileCache.delete(key));
+    }
+
+    return profile;
+  }
+
+  private async analyzWithLLM(
+    taskDescription: string,
+    context?: {
+      availableTools?: Tool[];
+      previousTasks?: string[];
+      constraints?: { maxCost?: number; maxLatency?: number };
+    }
+  ): Promise<TaskProfile> {
+    const llm = this.llm;
+    if (!llm) {
+      return this.analyzeHeuristically(taskDescription, context?.availableTools);
+    }
+
+    try {
+      const prompt = buildTaskProfilePrompt(taskDescription, {
+        previousTasks: context?.previousTasks,
+        constraints: context?.constraints,
+      });
+
+      const response = llm.complete
+        ? await llm.complete({
+            messages: [
+              {
+                role: 'system',
+                content: 'You are a task analysis expert. Analyze tasks and determine their characteristics.',
+              },
+              { role: 'user', content: prompt },
+            ],
+            temperature: 0.2,
+          })
+        : await llm.chat({
+            model: 'default',
+            messages: [
+              {
+                role: 'system',
+                content: 'You are a task analysis expert. Analyze tasks and determine their characteristics.',
+              },
+              { role: 'user', content: prompt },
+            ],
+            temperature: 0.2,
+          });
+
+      const parsed = parseTaskProfileResponse(response.content);
+      if (parsed) {
+        return parsed;
+      }
+    } catch {
+
+    }
+
+    return this.analyzeHeuristically(taskDescription, context?.availableTools);
+  }
+
+  private analyzeHeuristically(
+    taskDescription: string,
+    availableTools?: Tool[]
+  ): TaskProfile {
+    const lowerTask = taskDescription.toLowerCase();
+    const words = lowerTask.split(/\s+/);
+    const wordCount = words.length;
+
+    const domain = this.detectDomain(lowerTask);
+    const complexity = this.detectComplexity(lowerTask, wordCount);
+    const toolAnalysis = this.analyzeToolRequirements(lowerTask, availableTools);
+
+    return {
+      complexity,
+      domain,
+      estimatedTokens: this.estimateTokens(wordCount, complexity),
+      requiresTools: toolAnalysis.requiresTools,
+      toolIntensity: toolAnalysis.intensity,
+      reasoningDepth: this.estimateReasoningDepth(complexity, domain),
+      creativityLevel: domain === 'creative' ? 'high' : complexity === 'trivial' ? 'low' : 'moderate',
+      accuracyRequirement: this.estimateAccuracyRequirement(domain, lowerTask),
+      timeConstraint: this.detectTimeConstraint(lowerTask),
+    };
+  }
+
+  private detectDomain(task: string): TaskProfile['domain'] {
+    const scores: Record<string, number> = {
+      coding: 0,
+      reasoning: 0,
+      creative: 0,
+      factual: 0,
+      conversational: 0,
+    };
+
+    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+      for (const keyword of keywords) {
+        if (task.includes(keyword)) {
+          scores[domain] += keyword.length > 5 ? 2 : 1;
+        }
+      }
+    }
+
+    const maxDomain = Object.entries(scores).reduce((a, b) => (b[1] > a[1] ? b : a));
+    if (maxDomain[1] === 0) return 'general';
+    return maxDomain[0] as TaskProfile['domain'];
+  }
+
+  private detectComplexity(task: string, wordCount: number): TaskProfile['complexity'] {
+    for (const [level, indicators] of Object.entries(COMPLEXITY_INDICATORS).reverse()) {
+      for (const indicator of indicators) {
+        if (task.includes(indicator)) {
+          return level as TaskProfile['complexity'];
+        }
+      }
+    }
+
+    if (wordCount < 10) return 'trivial';
+    if (wordCount < 30) return 'simple';
+    if (wordCount < 100) return 'moderate';
+    if (wordCount < 300) return 'complex';
+    return 'extreme';
+  }
+
+  private analyzeToolRequirements(
+    task: string,
+    availableTools?: Tool[]
+  ): { requiresTools: boolean; intensity: TaskProfile['toolIntensity'] } {
+    const toolIndicators = [
+      'calculate', 'search', 'fetch', 'query', 'lookup', 'find',
+      'execute', 'run', 'call', 'invoke', 'use tool',
+    ];
+
+    let toolMentions = 0;
+    for (const indicator of toolIndicators) {
+      if (task.includes(indicator)) {
+        toolMentions++;
+      }
+    }
+
+    if (availableTools?.length) {
+      for (const tool of availableTools) {
+        if (task.includes(tool.name.toLowerCase())) {
+          toolMentions += 2;
+        }
+      }
+    }
+
+    if (toolMentions === 0) {
+      return { requiresTools: false, intensity: 'none' };
+    }
+    if (toolMentions <= 2) {
+      return { requiresTools: true, intensity: 'light' };
+    }
+    if (toolMentions <= 5) {
+      return { requiresTools: true, intensity: 'moderate' };
+    }
+    return { requiresTools: true, intensity: 'heavy' };
+  }
+
+  private estimateTokens(wordCount: number, complexity: TaskProfile['complexity']): number {
+    const baseMultiplier: Record<TaskProfile['complexity'], number> = {
+      trivial: 2,
+      simple: 3,
+      moderate: 5,
+      complex: 8,
+      extreme: 12,
+      expert: 15,
+    };
+
+    return Math.min(
+      wordCount * baseMultiplier[complexity] + 200,
+      32000
+    );
+  }
+
+  private estimateReasoningDepth(
+    complexity: TaskProfile['complexity'],
+    domain: TaskProfile['domain']
+  ): TaskProfile['reasoningDepth'] {
+    if (domain === 'reasoning') {
+      return complexity === 'trivial' ? 'moderate' : complexity === 'simple' ? 'deep' : 'exhaustive';
+    }
+
+    switch (complexity) {
+      case 'trivial':
+        return 'shallow';
+      case 'simple':
+        return 'shallow';
+      case 'moderate':
+        return 'moderate';
+      case 'complex':
+        return 'deep';
+      case 'extreme':
+      case 'expert':
+        return 'exhaustive';
+    }
+  }
+
+  private estimateAccuracyRequirement(
+    domain: TaskProfile['domain'],
+    task: string
+  ): TaskProfile['accuracyRequirement'] {
+    if (domain === 'coding' || domain === 'factual') {
+      return 'high';
+    }
+
+    const criticalIndicators = ['critical', 'exact', 'precise', 'must be correct', 'no errors'];
+    for (const indicator of criticalIndicators) {
+      if (task.includes(indicator)) {
+        return 'critical';
+      }
+    }
+
+    const approximateIndicators = ['rough', 'approximate', 'estimate', 'about', 'roughly'];
+    for (const indicator of approximateIndicators) {
+      if (task.includes(indicator)) {
+        return 'approximate';
+      }
+    }
+
+    return 'moderate';
+  }
+
+  private detectTimeConstraint(task: string): TaskProfile['timeConstraint'] {
+    const strictIndicators = ['urgent', 'asap', 'immediately', 'right now', 'hurry'];
+    const moderateIndicators = ['soon', 'quickly', 'fast', 'today'];
+    const relaxedIndicators = ['when possible', 'eventually', 'no rush'];
+
+    for (const indicator of strictIndicators) {
+      if (task.includes(indicator)) return 'strict';
+    }
+    for (const indicator of moderateIndicators) {
+      if (task.includes(indicator)) return 'moderate';
+    }
+    for (const indicator of relaxedIndicators) {
+      if (task.includes(indicator)) return 'relaxed';
+    }
+
+    return 'none';
+  }
+
+  private buildCacheKey(task: string): string {
+    return task.slice(0, 200).toLowerCase().replace(/\s+/g, ' ').trim();
+  }
+
+  clearCache(): void {
+    this.profileCache.clear();
+  }
+}

package/src/architecture-evolution/evolution-strategy.ts

@@ -0,0 +1,224 @@
+import type { EvolutionCandidate, EvolutionStrategy as IEvolutionStrategy } from '@cogitator-ai/types';
+
+export interface EvolutionStrategyOptions {
+  strategy: IEvolutionStrategy;
+  explorationBonus?: number;
+}
+
+export interface SelectionResult {
+  candidate: EvolutionCandidate;
+  score: number;
+  isExploration: boolean;
+  reasoning: string;
+}
+
+export class EvolutionStrategy {
+  private readonly strategy: IEvolutionStrategy;
+  private readonly explorationBonus: number;
+  private totalSelections = 0;
+
+  constructor(options: EvolutionStrategyOptions) {
+    this.strategy = options.strategy;
+    this.explorationBonus = options.explorationBonus ?? 2.0;
+  }
+
+  select(candidates: EvolutionCandidate[]): SelectionResult {
+    if (candidates.length === 0) {
+      throw new Error('No candidates to select from');
+    }
+
+    if (candidates.length === 1) {
+      return {
+        candidate: candidates[0],
+        score: candidates[0].score,
+        isExploration: false,
+        reasoning: 'Only one candidate available',
+      };
+    }
+
+    this.totalSelections++;
+
+    switch (this.strategy.type) {
+      case 'epsilon_greedy':
+        return this.epsilonGreedy(candidates);
+      case 'ucb':
+        return this.upperConfidenceBound(candidates);
+      case 'thompson_sampling':
+        return this.thompsonSampling(candidates);
+      default:
+        return this.epsilonGreedy(candidates);
+    }
+  }
+
+  private epsilonGreedy(candidates: EvolutionCandidate[]): SelectionResult {
+    const epsilon = this.strategy.epsilon ?? 0.1;
+    const isExploration = Math.random() < epsilon;
+
+    if (isExploration) {
+      const unexplored = candidates.filter((c) => c.evaluationCount === 0);
+      if (unexplored.length > 0) {
+        const candidate = unexplored[Math.floor(Math.random() * unexplored.length)];
+        return {
+          candidate,
+          score: 0,
+          isExploration: true,
+          reasoning: `Epsilon-greedy exploration: selected unexplored candidate ${candidate.id}`,
+        };
+      }
+
+      const candidate = candidates[Math.floor(Math.random() * candidates.length)];
+      return {
+        candidate,
+        score: candidate.score,
+        isExploration: true,
+        reasoning: `Epsilon-greedy exploration: randomly selected ${candidate.id}`,
+      };
+    }
+
+    const best = candidates.reduce((a, b) => (b.score > a.score ? b : a));
+    return {
+      candidate: best,
+      score: best.score,
+      isExploration: false,
+      reasoning: `Epsilon-greedy exploitation: selected best scoring ${best.id} (score: ${best.score.toFixed(3)})`,
+    };
+  }
+
+  private upperConfidenceBound(candidates: EvolutionCandidate[]): SelectionResult {
+    const c = this.strategy.explorationConstant ?? this.explorationBonus;
+
+    const ucbScores = candidates.map((candidate) => {
+      if (candidate.evaluationCount === 0) {
+        return { candidate, ucb: Infinity, isExploration: true };
+      }
+
+      const exploitation = candidate.score;
+      const exploration = c * Math.sqrt(Math.log(this.totalSelections + 1) / candidate.evaluationCount);
+      const ucb = exploitation + exploration;
+
+      return { candidate, ucb, isExploration: exploration > exploitation };
+    });
+
+    const best = ucbScores.reduce((a, b) => (b.ucb > a.ucb ? b : a));
+
+    return {
+      candidate: best.candidate,
+      score: best.ucb === Infinity ? 0 : best.ucb,
+      isExploration: best.isExploration,
+      reasoning: best.ucb === Infinity
+        ? `UCB: selected unexplored candidate ${best.candidate.id}`
+        : `UCB: selected ${best.candidate.id} with UCB score ${best.ucb.toFixed(3)} (base: ${best.candidate.score.toFixed(3)}, exploration bonus)`,
+    };
+  }
+
+  private thompsonSampling(candidates: EvolutionCandidate[]): SelectionResult {
+    const samples = candidates.map((candidate) => {
+      const alpha = candidate.evaluationCount > 0
+        ? candidate.score * candidate.evaluationCount + 1
+        : 1;
+      const beta = candidate.evaluationCount > 0
+        ? (1 - candidate.score) * candidate.evaluationCount + 1
+        : 1;
+
+      const sample = this.sampleBeta(alpha, beta);
+
+      return { candidate, sample };
+    });
+
+    const best = samples.reduce((a, b) => (b.sample > a.sample ? b : a));
+    const isExploration = best.candidate.evaluationCount < 3;
+
+    return {
+      candidate: best.candidate,
+      score: best.sample,
+      isExploration,
+      reasoning: `Thompson sampling: selected ${best.candidate.id} with sample ${best.sample.toFixed(3)} (evals: ${best.candidate.evaluationCount})`,
+    };
+  }
+
+  private sampleBeta(alpha: number, beta: number): number {
+    const gammaA = this.sampleGamma(alpha);
+    const gammaB = this.sampleGamma(beta);
+    return gammaA / (gammaA + gammaB);
+  }
+
+  private sampleGamma(shape: number): number {
+    if (shape < 1) {
+      return this.sampleGamma(shape + 1) * Math.pow(Math.random(), 1 / shape);
+    }
+
+    const d = shape - 1 / 3;
+    const c = 1 / Math.sqrt(9 * d);
+
+    while (true) {
+      let x: number;
+      let v: number;
+
+      do {
+        x = this.sampleNormal();
+        v = 1 + c * x;
+      } while (v <= 0);
+
+      v = v * v * v;
+      const u = Math.random();
+
+      if (u < 1 - 0.0331 * (x * x) * (x * x)) {
+        return d * v;
+      }
+
+      if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+        return d * v;
+      }
+    }
+  }
+
+  private sampleNormal(): number {
+    const u1 = Math.random();
+    const u2 = Math.random();
+    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  }
+
+  updateCandidate(candidate: EvolutionCandidate, reward: number): void {
+    const oldScore = candidate.score;
+    const oldCount = candidate.evaluationCount;
+
+    candidate.evaluationCount++;
+    candidate.score = (oldScore * oldCount + reward) / candidate.evaluationCount;
+  }
+
+  getExplorationRate(): number {
+    if (this.totalSelections === 0) return 1;
+
+    switch (this.strategy.type) {
+      case 'epsilon_greedy':
+        return this.strategy.epsilon ?? 0.1;
+      case 'ucb':
+        return Math.min(1, (this.strategy.explorationConstant ?? 2) / Math.sqrt(this.totalSelections));
+      case 'thompson_sampling':
+        return 0.5;
+      default:
+        return 0.1;
+    }
+  }
+
+  shouldExploreMore(candidates: EvolutionCandidate[]): boolean {
+    const unexploredCount = candidates.filter((c) => c.evaluationCount === 0).length;
+    if (unexploredCount > 0) return true;
+
+    const avgEvaluations = candidates.reduce((sum, c) => sum + c.evaluationCount, 0) / candidates.length;
+    if (avgEvaluations < 5) return true;
+
+    const scores = candidates.map((c) => c.score);
+    const maxScore = Math.max(...scores);
+    const minScore = Math.min(...scores);
+    const scoreRange = maxScore - minScore;
+
+    if (scoreRange > 0.3) return true;
+
+    return false;
+  }
+
+  reset(): void {
+    this.totalSelections = 0;
+  }
+}

package/src/architecture-evolution/index.ts

@@ -0,0 +1,26 @@
+export {
+  CapabilityAnalyzer,
+  type CapabilityAnalyzerOptions,
+} from './capability-analyzer';
+
+export {
+  EvolutionStrategy,
+  type EvolutionStrategyOptions,
+  type SelectionResult,
+} from './evolution-strategy';
+
+export {
+  ParameterOptimizer,
+  type ParameterOptimizerOptions,
+  type OptimizationResult,
+} from './parameter-optimizer';
+
+export {
+  buildTaskProfilePrompt,
+  buildCandidateGenerationPrompt,
+  buildPerformanceAnalysisPrompt,
+  parseTaskProfileResponse,
+  parseCandidateGenerationResponse,
+  parsePerformanceAnalysisResponse,
+  ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT,
+} from './prompts';