@cogitator-ai/self-modifying 17.0.17 → 18.0.0

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

@@ -1,5 +1,21 @@
+import { createHash } from 'node:crypto';
 import type { Tool, LLMBackend, TaskProfile } from '@cogitator-ai/types';
 import { buildTaskProfilePrompt, parseTaskProfileResponse } from './prompts';
+import { llmChat } from '../utils/llm-helper';
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function containsPhrase(text: string, phrase: string): boolean {
+  return new RegExp(`(?:^|[^a-z0-9])${escapeRegExp(phrase)}(?:s|es|ed|ing)?(?:$|[^a-z0-9])`).test(
+    text
+  );
+}
+
+function tokenize(text: string): string[] {
+  return text.split(/[^a-z0-9-]+/).filter(Boolean);
+}
 
 export interface CapabilityAnalyzerOptions {
   llm?: LLMBackend;
@@ -121,6 +137,7 @@ const COMPLEXITY_INDICATORS = {
   simple: ['explain', 'define', 'list', 'describe', 'show'],
   moderate: ['compare', 'analyze', 'summarize', 'evaluate', 'implement'],
   complex: ['design', 'architect', 'optimize', 'comprehensive', 'detailed'],
+  expert: ['expert', 'advanced', 'specialized', 'intricate', 'sophisticated'],
   extreme: ['novel', 'research', 'breakthrough', 'state-of-the-art', 'cutting-edge'],
 };
 
@@ -145,7 +162,7 @@ export class CapabilityAnalyzer {
       constraints?: { maxCost?: number; maxLatency?: number };
     }
   ): Promise<TaskProfile> {
-    const cacheKey = this.buildCacheKey(taskDescription);
+    const cacheKey = this.buildCacheKey(taskDescription, context);
     const cached = this.profileCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
       return cached.profile;
@@ -189,32 +206,20 @@ export class CapabilityAnalyzer {
         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: this.model,
-            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);
+      const content = await llmChat(
+        llm,
+        [
+          {
+            role: 'system',
+            content:
+              'You are a task analysis expert. Analyze tasks and determine their characteristics.',
+          },
+          { role: 'user', content: prompt },
+        ],
+        { model: this.model, temperature: 0.2 }
+      );
+
+      const parsed = parseTaskProfileResponse(content);
       if (parsed) {
         return parsed;
       }
@@ -225,8 +230,7 @@ export class CapabilityAnalyzer {
 
   private analyzeHeuristically(taskDescription: string, availableTools?: Tool[]): TaskProfile {
     const lowerTask = taskDescription.toLowerCase();
-    const words = lowerTask.split(/\s+/);
-    const wordCount = words.length;
+    const wordCount = tokenize(lowerTask).length;
 
     const domain = this.detectDomain(lowerTask);
     const complexity = this.detectComplexity(lowerTask, wordCount);
@@ -237,6 +241,8 @@ export class CapabilityAnalyzer {
       domain,
       estimatedTokens: this.estimateTokens(wordCount, complexity),
       requiresTools: toolAnalysis.requiresTools,
+      requiresReasoning: domain === 'reasoning' || domain === 'coding',
+      requiresCreativity: domain === 'creative',
       toolIntensity: toolAnalysis.intensity,
       reasoningDepth: this.estimateReasoningDepth(complexity, domain),
       creativityLevel:
@@ -257,7 +263,7 @@ export class CapabilityAnalyzer {
 
     for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
       for (const keyword of keywords) {
-        if (task.includes(keyword)) {
+        if (containsPhrase(task, keyword)) {
           scores[domain] += keyword.length > 5 ? 2 : 1;
         }
       }
@@ -269,7 +275,7 @@ export class CapabilityAnalyzer {
   }
 
   private detectComplexity(task: string, wordCount: number): TaskProfile['complexity'] {
-    const taskWords = new Set(task.split(/\s+/));
+    const taskWords = new Set(tokenize(task));
 
     for (const [level, indicators] of Object.entries(COMPLEXITY_INDICATORS).reverse()) {
       for (const indicator of indicators) {
@@ -306,14 +312,14 @@ export class CapabilityAnalyzer {
 
     let toolMentions = 0;
     for (const indicator of toolIndicators) {
-      if (task.includes(indicator)) {
+      if (containsPhrase(task, indicator)) {
         toolMentions++;
       }
     }
 
     if (availableTools?.length) {
       for (const tool of availableTools) {
-        if (task.includes(tool.name.toLowerCase())) {
+        if (containsPhrase(task, tool.name.toLowerCase())) {
           toolMentions += 2;
         }
       }
@@ -375,20 +381,20 @@ export class CapabilityAnalyzer {
     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)) {
+      if (containsPhrase(task, indicator)) {
         return 'critical';
       }
     }
 
+    if (domain === 'coding' || domain === 'factual') {
+      return 'high';
+    }
+
     const approximateIndicators = ['rough', 'approximate', 'estimate', 'about', 'roughly'];
     for (const indicator of approximateIndicators) {
-      if (task.includes(indicator)) {
+      if (containsPhrase(task, indicator)) {
         return 'approximate';
       }
     }
@@ -402,20 +408,33 @@ export class CapabilityAnalyzer {
     const relaxedIndicators = ['when possible', 'eventually', 'no rush'];
 
     for (const indicator of strictIndicators) {
-      if (task.includes(indicator)) return 'strict';
+      if (containsPhrase(task, indicator)) return 'strict';
     }
     for (const indicator of moderateIndicators) {
-      if (task.includes(indicator)) return 'moderate';
+      if (containsPhrase(task, indicator)) return 'moderate';
     }
     for (const indicator of relaxedIndicators) {
-      if (task.includes(indicator)) return 'relaxed';
+      if (containsPhrase(task, indicator)) return 'relaxed';
     }
 
     return 'none';
   }
 
-  private buildCacheKey(task: string): string {
-    return task.slice(0, 200).toLowerCase().replace(/\s+/g, ' ').trim();
+  private buildCacheKey(
+    task: string,
+    context?: {
+      availableTools?: Tool[];
+      previousTasks?: string[];
+      constraints?: { maxCost?: number; maxLatency?: number };
+    }
+  ): string {
+    const raw = JSON.stringify([
+      task.toLowerCase().replace(/\s+/g, ' ').trim(),
+      (context?.availableTools ?? []).map((t) => t.name).sort(),
+      context?.previousTasks ?? [],
+      context?.constraints ?? {},
+    ]);
+    return createHash('sha256').update(raw).digest('hex');
   }
 
   clearCache(): void {

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

@@ -152,8 +152,9 @@ export class EvolutionStrategy {
 
     const d = shape - 1 / 3;
     const c = 1 / Math.sqrt(9 * d);
+    const maxIterations = 1000;
 
-    while (true) {
+    for (let i = 0; i < maxIterations; i++) {
       let x: number;
       let v: number;
 
@@ -173,6 +174,8 @@ export class EvolutionStrategy {
         return d * v;
       }
     }
+
+    return d;
   }
 
   private sampleNormal(): number {
@@ -202,7 +205,7 @@ export class EvolutionStrategy {
           (this.strategy.explorationConstant ?? 2) / Math.sqrt(this.totalSelections)
         );
       case 'thompson_sampling':
-        return 0.5;
+        return Math.max(0.05, 1 / Math.sqrt(this.totalSelections + 1));
       default:
         return 0.1;
     }

package/src/architecture-evolution/index.ts

@@ -10,6 +10,7 @@ export {
   ParameterOptimizer,
   type ParameterOptimizerOptions,
   type OptimizationResult,
+  type HistoricalRecord,
 } from './parameter-optimizer';
 
 export {
@@ -19,5 +20,6 @@ export {
   parseTaskProfileResponse,
   parseCandidateGenerationResponse,
   parsePerformanceAnalysisResponse,
+  sanitizeCandidateConfig,
   ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT,
 } from './prompts';

package/src/architecture-evolution/parameter-optimizer.ts

@@ -13,17 +13,23 @@ import {
   buildPerformanceAnalysisPrompt,
   parseCandidateGenerationResponse,
   parsePerformanceAnalysisResponse,
+  MAX_TOKENS_RANGE,
+  REFLECTION_DEPTH_RANGE,
+  TEMPERATURE_RANGE,
 } from './prompts';
+import { llmChat } from '../utils/llm-helper';
 
 export interface ParameterOptimizerOptions {
   llm: LLMBackend;
   config: ArchitectureEvolutionConfig;
   baseConfig: ArchitectureConfig;
   model?: string;
+  availableModels?: string[];
 }
 
 export interface OptimizationResult {
   recommendedConfig: ArchitectureConfig;
+  taskProfile: TaskProfile;
   candidate: EvolutionCandidate | null;
   metrics: EvolutionMetrics;
   shouldAdopt: boolean;
@@ -31,7 +37,7 @@ export interface OptimizationResult {
   reasoning: string;
 }
 
-interface HistoricalRecord {
+export interface HistoricalRecord {
   taskProfile: TaskProfile;
   config: Partial<ArchitectureConfig>;
   score: number;
@@ -44,6 +50,7 @@ export class ParameterOptimizer {
   private readonly config: ArchitectureEvolutionConfig;
   private readonly model: string;
   private readonly baseConfig: ArchitectureConfig;
+  private readonly availableModels: string[];
   private readonly capabilityAnalyzer: CapabilityAnalyzer;
   private readonly evolutionStrategy: EvolutionStrategy;
 
@@ -58,6 +65,7 @@ export class ParameterOptimizer {
     this.config = options.config;
     this.model = options.model ?? 'default';
     this.baseConfig = options.baseConfig;
+    this.availableModels = options.availableModels ?? [];
 
     this.capabilityAnalyzer = new CapabilityAnalyzer({
       llm: options.llm,
@@ -79,15 +87,28 @@ export class ParameterOptimizer {
     }
 
     const selection = this.evolutionStrategy.select(this.candidates);
+    const candidate = selection.candidate;
+
+    const mergedConfig = this.mergeConfigs(this.baseConfig, candidate.config);
 
-    const mergedConfig = this.mergeConfigs(this.baseConfig, selection.candidate.config);
+    const bestEvaluated = this.candidates
+      .filter((c) => c.evaluationCount > 0)
+      .sort((a, b) => b.score - a.score)[0];
+
+    const threshold = this.config.adaptationThreshold ?? 0.1;
+    const shouldAdopt =
+      candidate.evaluationCount === 0 ||
+      !bestEvaluated ||
+      candidate.id === bestEvaluated.id ||
+      candidate.score >= bestEvaluated.score - threshold;
 
     return {
       recommendedConfig: mergedConfig,
-      candidate: selection.candidate,
+      taskProfile: profile,
+      candidate,
       metrics: this.calculateMetrics(),
-      shouldAdopt: true,
-      confidence: selection.score,
+      shouldAdopt,
+      confidence: candidate.evaluationCount > 0 ? candidate.score : 0.5,
       reasoning: selection.reasoning,
     };
   }
@@ -134,11 +155,13 @@ export class ParameterOptimizer {
     const prompt = buildCandidateGenerationPrompt(
       profile,
       this.baseConfig,
-      this.getRelevantHistory(profile)
+      this.getRelevantHistory(profile),
+      { availableModels: this.availableModels }
     );
 
     try {
-      const response = await this.callLLM(
+      const content = await llmChat(
+        this.llm,
         [
           {
             role: 'system',
@@ -146,14 +169,17 @@ export class ParameterOptimizer {
           },
           { role: 'user', content: prompt },
         ],
-        0.5
+        { model: this.model, temperature: 0.5 }
       );
 
-      const generated = parseCandidateGenerationResponse(response.content);
+      const generated = parseCandidateGenerationResponse(content, {
+        availableModels: this.availableModels,
+      }).filter((c) => c.risk !== 'high');
 
+      const maxCandidates = this.config.maxCandidates ?? 10;
       this.candidates = [
         this.createBaselineCandidate(),
-        ...generated.map((c) => ({
+        ...generated.slice(0, Math.max(0, maxCandidates - 1)).map((c) => ({
           ...c,
           generation: this.currentGeneration,
         })),
@@ -247,22 +273,28 @@ export class ParameterOptimizer {
     const mutated = { ...config };
     const mutationRate = 0.3;
 
-    if (Math.random() < mutationRate && mutated.temperature !== undefined) {
+    if (Math.random() < mutationRate) {
+      const base = mutated.temperature ?? this.baseConfig.temperature;
       mutated.temperature = Math.max(
-        0,
-        Math.min(2, mutated.temperature + (Math.random() - 0.5) * 0.3)
+        TEMPERATURE_RANGE.min,
+        Math.min(TEMPERATURE_RANGE.max, base + (Math.random() - 0.5) * 0.3)
       );
     }
 
-    if (Math.random() < mutationRate && mutated.maxTokens !== undefined) {
+    if (Math.random() < mutationRate) {
+      const base = mutated.maxTokens ?? this.baseConfig.maxTokens;
       const delta = Math.floor((Math.random() - 0.5) * 1000);
-      mutated.maxTokens = Math.max(100, Math.min(32000, mutated.maxTokens + delta));
+      mutated.maxTokens = Math.max(
+        MAX_TOKENS_RANGE.min,
+        Math.min(MAX_TOKENS_RANGE.max, base + delta)
+      );
     }
 
-    if (Math.random() < mutationRate && mutated.reflectionDepth !== undefined) {
+    if (Math.random() < mutationRate) {
+      const base = mutated.reflectionDepth ?? this.baseConfig.reflectionDepth;
       mutated.reflectionDepth = Math.max(
-        0,
-        Math.min(5, mutated.reflectionDepth + Math.round(Math.random() * 2 - 1))
+        REFLECTION_DEPTH_RANGE.min,
+        Math.min(REFLECTION_DEPTH_RANGE.max, base + Math.round(Math.random() * 2 - 1))
       );
     }
 
@@ -316,22 +348,26 @@ export class ParameterOptimizer {
   }
 
   private shouldEvolve(): boolean {
-    const minEvaluations = this.candidates.reduce(
+    const evaluatedCandidates = this.candidates.filter((c) => c.evaluationCount > 0);
+    if (evaluatedCandidates.length === 0) return false;
+
+    const minEvaluations = evaluatedCandidates.reduce(
       (min, c) => Math.min(min, c.evaluationCount),
       Infinity
     );
 
-    if (minEvaluations < 3) return false;
+    const minRequired = this.config.minEvaluationsBeforeEvolution ?? 3;
+    if (minEvaluations < minRequired) return false;
 
     const evaluationsSinceEvolution = this.history.filter(
-      (h) => h.timestamp > this.getLastEvolutionTime()
+      (h) => h.timestamp > this.lastEvolutionTimestamp
     ).length;
 
-    return evaluationsSinceEvolution >= 5;
+    return evaluationsSinceEvolution >= this.getEvaluationWindow();
   }
 
-  private getLastEvolutionTime(): number {
-    return this.lastEvolutionTimestamp;
+  private getEvaluationWindow(): number {
+    return Math.max(1, this.config.evaluationWindow ?? 10);
   }
 
   private getRelevantHistory(profile: TaskProfile): HistoricalRecord[] {
@@ -340,7 +376,7 @@ export class ParameterOptimizer {
         (h) =>
           h.taskProfile.domain === profile.domain || h.taskProfile.complexity === profile.complexity
       )
-      .slice(-10);
+      .slice(-this.getEvaluationWindow());
   }
 
   private mergeConfigs(
@@ -418,13 +454,28 @@ export class ParameterOptimizer {
       fields++;
     }
 
+    if (
+      a.toolStrategy !== undefined &&
+      b.toolStrategy !== undefined &&
+      a.toolStrategy !== b.toolStrategy
+    ) {
+      distance += 1;
+      fields++;
+    }
+
+    if (a.reflectionDepth !== undefined && b.reflectionDepth !== undefined) {
+      distance += Math.abs(a.reflectionDepth - b.reflectionDepth) / 5;
+      fields++;
+    }
+
     return fields > 0 ? distance / fields : 0;
   }
 
   private calculateConvergenceRate(): number {
-    if (this.history.length < 10) return 0;
+    const window = this.getEvaluationWindow();
+    if (this.history.length < window) return 0;
 
-    const recentScores = this.history.slice(-10).map((h) => h.score);
+    const recentScores = this.history.slice(-window).map((h) => h.score);
     const variance = this.calculateVariance(recentScores);
 
     return Math.max(0, 1 - variance * 4);
@@ -471,30 +522,21 @@ export class ParameterOptimizer {
     const prompt = buildPerformanceAnalysisPrompt(evaluatedCandidates, results);
 
     try {
-      const response = await this.callLLM(
+      const content = await llmChat(
+        this.llm,
         [
           { role: 'system', content: 'You are an AI performance analyst.' },
           { role: 'user', content: prompt },
         ],
-        0.2
+        { model: this.model, temperature: 0.2 }
       );
 
-      return parsePerformanceAnalysisResponse(response.content);
+      return parsePerformanceAnalysisResponse(content);
     } catch {
       return null;
     }
   }
 
-  private async callLLM(
-    messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>,
-    temperature: number
-  ) {
-    if (this.llm.complete) {
-      return this.llm.complete({ messages, temperature });
-    }
-    return this.llm.chat({ model: this.model, messages, temperature });
-  }
-
   getCandidates(): EvolutionCandidate[] {
     return [...this.candidates];
   }