@cogitator-ai/self-modifying 0.1.0 → 2.0.0

package/src/meta-reasoning/meta-reasoner.ts

@@ -14,7 +14,11 @@ import type {
   MetaOpportunity,
 } from '@cogitator-ai/types';
 import { DEFAULT_META_REASONING_CONFIG } from '@cogitator-ai/types';
-import { ObservationCollector, type ActionRecord, type ObservationContext } from './observation-collector';
+import {
+  ObservationCollector,
+  type ActionRecord,
+  type ObservationContext,
+} from './observation-collector';
 import { StrategySelector } from './strategy-selector';
 import {
   buildMetaAssessmentPrompt,
@@ -98,8 +102,7 @@ export class MetaReasoner {
     switch (trigger) {
       case 'iteration_complete':
         return (
-          context.iteration > 0 &&
-          context.iteration % this.config.triggerAfterIterations === 0
+          context.iteration > 0 && context.iteration % this.config.triggerAfterIterations === 0
         );
 
       case 'confidence_drop':
@@ -235,10 +238,7 @@ export class MetaReasoner {
 
     switch (recommendation.action) {
       case 'switch_mode':
-        if (
-          recommendation.newMode &&
-          this.config.allowedModes.includes(recommendation.newMode)
-        ) {
+        if (recommendation.newMode && this.config.allowedModes.includes(recommendation.newMode)) {
           newConfig = this.getModeConfig(recommendation.newMode);
           adaptationType = 'mode_switch';
           this.currentMode.set(runId, recommendation.newMode);
@@ -286,14 +286,11 @@ export class MetaReasoner {
     const runAdaptations = this.adaptations.get(runId) ?? [];
     const lastAdaptation = runAdaptations[runAdaptations.length - 1];
 
-    if (!lastAdaptation || !lastAdaptation.rollbackable) {
+    if (!lastAdaptation?.rollbackable) {
       return null;
     }
 
-    if (
-      lastAdaptation.rollbackDeadline &&
-      Date.now() > lastAdaptation.rollbackDeadline
-    ) {
+    if (lastAdaptation.rollbackDeadline && Date.now() > lastAdaptation.rollbackDeadline) {
       return null;
     }
 
@@ -328,11 +325,7 @@ export class MetaReasoner {
     if (adaptation) {
       adaptation.outcome = outcome;
 
-      if (
-        this.config.rollbackOnDecline &&
-        !outcome.improved &&
-        adaptation.rollbackable
-      ) {
+      if (this.config.rollbackOnDecline && !outcome.improved && adaptation.rollbackable) {
         this.rollback(runId);
       }
     }

package/src/meta-reasoning/observation-collector.ts

@@ -1,8 +1,4 @@
-import type {
-  MetaObservation,
-  ReasoningMode,
-  Insight,
-} from '@cogitator-ai/types';
+import type { MetaObservation, ReasoningMode, Insight } from '@cogitator-ai/types';
 
 export interface ActionRecord {
   type: string;
@@ -56,10 +52,7 @@ export class ObservationCollector {
     }
   }
 
-  collect(
-    context: ObservationContext,
-    insights: Insight[]
-  ): MetaObservation {
+  collect(context: ObservationContext, insights: Insight[]): MetaObservation {
     const { runId, iteration, goal, currentMode } = context;
     const prevObservations = this.observations.get(runId) ?? [];
     const lastObs = prevObservations[prevObservations.length - 1];
@@ -69,9 +62,7 @@ export class ObservationCollector {
     const currentConfidence = confidenceHist[confidenceHist.length - 1] ?? 0.5;
     const progressScore = this.calculateProgress(actions);
     const progressDelta = lastObs ? progressScore - lastObs.progressScore : 0;
-    const stagnationCount = progressDelta < 0.05
-      ? (lastObs?.stagnationCount ?? 0) + 1
-      : 0;
+    const stagnationCount = progressDelta < 0.05 ? (lastObs?.stagnationCount ?? 0) + 1 : 0;
     const repetitionScore = this.calculateRepetition(actions);
     const toolSuccessRate = this.calculateToolSuccessRate(actions);
     const confidenceTrend = this.calculateTrend(confidenceHist);

package/src/meta-reasoning/prompts.ts

@@ -1,8 +1,4 @@
-import type {
-  MetaObservation,
-  ReasoningMode,
-  ReasoningModeConfig,
-} from '@cogitator-ai/types';
+import type { MetaObservation, ReasoningMode, ReasoningModeConfig } from '@cogitator-ai/types';
 
 export function buildMetaAssessmentPrompt(
   observation: MetaObservation,
@@ -44,10 +40,14 @@ Iterations remaining: ${observation.iterationsRemaining}
 ${(observation.recentActions ?? []).map((a) => `- ${a.type}: ${a.toolName ?? 'N/A'} ${a.error ? '(ERROR: ' + a.error + ')' : ''}`).join('\n') || 'None'}
 
 ## Recent Insights
-${(observation.recentInsights ?? [] as Array<{ type?: string; content?: string }>).map((i) => {
-  const insight = i as { type?: string; content?: string };
-  return `- [${insight.type ?? 'insight'}] ${insight.content ?? ''}`;
-}).join('\n') || 'None'}
+${
+  (observation.recentInsights ?? ([] as Array<{ type?: string; content?: string }>))
+    .map((i) => {
+      const insight = i as { type?: string; content?: string };
+      return `- [${insight.type ?? 'insight'}] ${insight.content ?? ''}`;
+    })
+    .join('\n') || 'None'
+}
 
 ## Available Modes for Switching
 ${context.allowedModes.map((m) => `- ${m}`).join('\n')}
@@ -111,7 +111,7 @@ export interface ParsedAssessment {
 
 export function parseMetaAssessmentResponse(content: string): ParsedAssessment | null {
   try {
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    const jsonMatch = /\{[\s\S]*\}/.exec(content);
     if (!jsonMatch) return null;
     return JSON.parse(jsonMatch[0]) as ParsedAssessment;
   } catch {

package/src/meta-reasoning/strategy-selector.ts

@@ -78,7 +78,11 @@ export class StrategySelector {
           score += 0.2;
           reasons.push('Thorough for complex tasks');
         }
-        if (!profile.timeConstraint || profile.timeConstraint === 'none' || profile.timeConstraint === 'relaxed') {
+        if (
+          !profile.timeConstraint ||
+          profile.timeConstraint === 'none' ||
+          profile.timeConstraint === 'relaxed'
+        ) {
           score += 0.1;
           reasons.push('Has time for systematic approach');
         }

package/src/self-modifying-agent.ts

@@ -154,7 +154,7 @@ export class SelfModifyingAgent {
       checkpoints: [],
     };
 
-    this.emitter.emit({
+    void this.emitter.emit({
       type: 'run_started',
       runId,
       timestamp: new Date(),
@@ -172,7 +172,7 @@ export class SelfModifyingAgent {
 
       const modeConfig = this.metaReasoner.initializeRun(runId);
 
-      this.emitter.emit({
+      void this.emitter.emit({
         type: 'strategy_changed',
         runId,
         timestamp: new Date(),
@@ -192,7 +192,7 @@ export class SelfModifyingAgent {
         finalConfig: { ...this.currentContext.currentConfig },
       };
 
-      this.emitter.emit({
+      void this.emitter.emit({
         type: 'run_completed',
         runId,
         timestamp: new Date(),
@@ -205,7 +205,7 @@ export class SelfModifyingAgent {
 
       return result;
     } catch (error) {
-      this.emitter.emit({
+      void this.emitter.emit({
         type: 'run_completed',
         runId,
         timestamp: new Date(),
@@ -232,7 +232,7 @@ export class SelfModifyingAgent {
     if (result.success && result.tool) {
       await this.toolStore.save(result.tool);
 
-      this.emitter.emit({
+      void this.emitter.emit({
         type: 'tool_generation_completed',
         runId: this.currentContext?.runId || 'manual',
         timestamp: new Date(),
@@ -247,7 +247,7 @@ export class SelfModifyingAgent {
       return result.tool;
     }
 
-    this.emitter.emit({
+    void this.emitter.emit({
       type: 'tool_generation_completed',
       runId: this.currentContext?.runId || 'manual',
       timestamp: new Date(),
@@ -262,11 +262,7 @@ export class SelfModifyingAgent {
     return null;
   }
 
-  async recordToolUsage(
-    toolId: string,
-    success: boolean,
-    executionTime: number
-  ): Promise<void> {
+  async recordToolUsage(toolId: string, success: boolean, executionTime: number): Promise<void> {
     await this.toolStore.recordUsage({
       toolId,
       timestamp: new Date(),
@@ -299,7 +295,7 @@ export class SelfModifyingAgent {
 
     this.currentContext.checkpoints.push(checkpoint);
 
-    this.emitter.emit({
+    void this.emitter.emit({
       type: 'checkpoint_created',
       runId: this.currentContext.runId,
       timestamp: new Date(),
@@ -317,7 +313,7 @@ export class SelfModifyingAgent {
       this.currentContext.tools = restored.tools;
     }
 
-    this.emitter.emit({
+    void this.emitter.emit({
       type: 'rollback_performed',
       runId: this.currentContext?.runId || 'manual',
       timestamp: new Date(),
@@ -333,12 +329,7 @@ export class SelfModifyingAgent {
   private async ensureInitialized(): Promise<void> {
     if (this.isInitialized) return;
 
-    const activeToos = await this.toolStore.list({ status: 'active' });
-    for (const tool of activeToos) {
-      if (tool.validationScore && tool.validationScore > 0.8) {
-
-      }
-    }
+    await this.toolStore.list({ status: 'active' });
 
     this.isInitialized = true;
   }
@@ -364,7 +355,14 @@ export class SelfModifyingAgent {
       metaReasoning: {
         enabled: true,
         defaultMode: 'analytical',
-        allowedModes: ['analytical', 'creative', 'systematic', 'intuitive', 'reflective', 'exploratory'],
+        allowedModes: [
+          'analytical',
+          'creative',
+          'systematic',
+          'intuitive',
+          'reflective',
+          'exploratory',
+        ],
         modeProfiles: {
           analytical: { mode: 'analytical', temperature: 0.3, depth: 3 },
           creative: { mode: 'creative', temperature: 0.9, depth: 2 },
@@ -413,7 +411,10 @@ export class SelfModifyingAgent {
       enabled: partial.enabled ?? defaults.enabled,
       toolGeneration: { ...defaults.toolGeneration, ...partial.toolGeneration },
       metaReasoning: { ...defaults.metaReasoning, ...partial.metaReasoning },
-      architectureEvolution: { ...defaults.architectureEvolution, ...partial.architectureEvolution },
+      architectureEvolution: {
+        ...defaults.architectureEvolution,
+        ...partial.architectureEvolution,
+      },
       constraints: { ...defaults.constraints, ...partial.constraints },
     };
   }
@@ -439,7 +440,7 @@ export class SelfModifyingAgent {
         if (validation.valid) {
           this.currentContext.currentConfig = result.recommendedConfig;
 
-          this.emitter.emit({
+          void this.emitter.emit({
             type: 'architecture_evolved',
             runId: this.currentContext.runId,
             timestamp: new Date(),
@@ -451,23 +452,18 @@ export class SelfModifyingAgent {
           });
         }
       }
-    } catch {
-
-    }
+    } catch {}
   }
 
   private async analyzeAndGenerateTools(input: string): Promise<void> {
     if (!this.currentContext) return;
 
     try {
-      const analysis = await this.gapAnalyzer.analyze(
-        input,
-        this.currentContext.tools
-      );
+      const analysis = await this.gapAnalyzer.analyze(input, this.currentContext.tools);
 
       for (const gap of analysis.gaps) {
         if (gap.confidence >= this.config.toolGeneration.minConfidenceForGeneration) {
-          this.emitter.emit({
+          void this.emitter.emit({
             type: 'tool_generation_started',
             runId: this.currentContext.runId,
             timestamp: new Date(),
@@ -483,15 +479,10 @@ export class SelfModifyingAgent {
           }
         }
       }
-    } catch {
-
-    }
+    } catch {}
   }
 
-  private async executeWithMetaReasoning(
-    input: string,
-    runId: string
-  ): Promise<string> {
+  private async executeWithMetaReasoning(input: string, runId: string): Promise<string> {
     if (!this.currentContext) {
       throw new Error('No active run context');
     }
@@ -520,15 +511,17 @@ export class SelfModifyingAgent {
 
       this.currentContext.observations.push(observation);
 
-      if (this.metaReasoner.shouldTrigger(runId, 'periodic', {
-        iteration,
-        confidence: this.estimateConfidence(output),
-        progressDelta: output.length > 0 ? 0.1 : 0,
-        stagnationCount: 0,
-      })) {
+      if (
+        this.metaReasoner.shouldTrigger(runId, 'periodic', {
+          iteration,
+          confidence: this.estimateConfidence(output),
+          progressDelta: output.length > 0 ? 0.1 : 0,
+          stagnationCount: 0,
+        })
+      ) {
         const assessment = await this.metaReasoner.assess(observation);
 
-        this.emitter.emit({
+        void this.emitter.emit({
           type: 'meta_assessment',
           runId,
           timestamp: new Date(),
@@ -544,7 +537,7 @@ export class SelfModifyingAgent {
           if (adaptation) {
             this.currentContext.adaptations.push(adaptation);
 
-            this.emitter.emit({
+            void this.emitter.emit({
               type: 'strategy_changed',
               runId,
               timestamp: new Date(),

package/src/tool-generation/gap-analyzer.ts

@@ -41,22 +41,21 @@ export class GapAnalyzer {
       description: t.description,
     }));
 
-    const prompt = buildGapAnalysisPrompt(
-      userIntent,
-      toolSummaries,
-      context?.failedAttempts
-    );
+    const prompt = buildGapAnalysisPrompt(userIntent, toolSummaries, context?.failedAttempts);
 
-    const response = await this.callLLM([
-      {
-        role: 'system',
-        content: `You are a capability analyzer for AI agents.
+    const response = await this.callLLM(
+      [
+        {
+          role: 'system',
+          content: `You are a capability analyzer for AI agents.
 Identify gaps between user intent and available tools.
 Be conservative - only report gaps when truly necessary.
 Consider tool composition before suggesting new tools.`,
-      },
-      { role: 'user', content: prompt },
-    ], 0.3);
+        },
+        { role: 'user', content: prompt },
+      ],
+      0.3
+    );
 
     const parsed = parseGapAnalysisResponse(response.content);
     const filteredGaps = this.filterAndPrioritizeGaps(
@@ -149,7 +148,7 @@ Consider tool composition before suggesting new tools.`,
       return 1.0;
     }
 
-    const intentWords = userIntent.toLowerCase().split(/\s+/).length;
+    const _intentWords = userIntent.toLowerCase().split(/\s+/).length;
     const toolDescriptionWords = availableTools
       .map((t) => t.description.toLowerCase().split(/\s+/))
       .flat();
@@ -186,7 +185,9 @@ Consider tool composition before suggesting new tools.`,
     for (const [action, related] of Object.entries(keywords)) {
       if (intentLower.includes(action)) {
         const relatedTools = availableTools.filter((t) =>
-          related.some((r) => t.name.toLowerCase().includes(r) || t.description.toLowerCase().includes(r))
+          related.some(
+            (r) => t.name.toLowerCase().includes(r) || t.description.toLowerCase().includes(r)
+          )
         );
 
         if (relatedTools.length >= 2) {
@@ -214,7 +215,10 @@ Consider tool composition before suggesting new tools.`,
   }
 
   private buildCacheKey(userIntent: string, tools: Tool[]): string {
-    const toolSignature = tools.map((t) => t.name).sort().join(',');
+    const toolSignature = tools
+      .map((t) => t.name)
+      .sort()
+      .join(',');
     return `${userIntent.slice(0, 100)}|${toolSignature}`;
   }
 

package/src/tool-generation/generated-tool-store.ts

@@ -73,10 +73,7 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
     return deleted;
   }
 
-  async updateStatus(
-    id: string,
-    status: GeneratedTool['status']
-  ): Promise<boolean> {
+  async updateStatus(id: string, status: GeneratedTool['status']): Promise<boolean> {
     const tool = this.tools.get(id);
     if (!tool) return false;
 
@@ -121,7 +118,9 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
     };
   }
 
-  async getTopTools(limit: number = 10): Promise<Array<{ tool: GeneratedTool; metrics: ToolMetrics }>> {
+  async getTopTools(
+    limit: number = 10
+  ): Promise<Array<{ tool: GeneratedTool; metrics: ToolMetrics }>> {
     const result: Array<{ tool: GeneratedTool; metrics: ToolMetrics }> = [];
 
     for (const tool of this.tools.values()) {
@@ -149,9 +148,7 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
     for (const tool of this.tools.values()) {
       if (tool.status === 'deprecated') continue;
 
-      const toolWords = new Set(
-        `${tool.name} ${tool.description}`.toLowerCase().split(/\s+/)
-      );
+      const toolWords = new Set(`${tool.name} ${tool.description}`.toLowerCase().split(/\s+/));
 
       let matchCount = 0;
       for (const word of descWords) {

package/src/tool-generation/prompts.ts

@@ -26,9 +26,7 @@ export function buildGapAnalysisPrompt(
   availableTools: Array<{ name: string; description: string }>,
   failedAttempts?: string[]
 ): string {
-  const toolList = availableTools
-    .map((t) => `- ${t.name}: ${t.description}`)
-    .join('\n');
+  const toolList = availableTools.map((t) => `- ${t.name}: ${t.description}`).join('\n');
 
   const failureContext = failedAttempts?.length
     ? `\n\nPrevious failed attempts:\n${failedAttempts.map((f) => `- ${f}`).join('\n')}`
@@ -207,7 +205,7 @@ export function parseGapAnalysisResponse(response: string): {
   canProceed: boolean;
   alternativeApproach?: string;
 } {
-  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  const jsonMatch = /\{[\s\S]*\}/.exec(response);
   if (!jsonMatch) {
     return { hasGap: false, gaps: [], canProceed: true };
   }
@@ -240,7 +238,7 @@ export function parseGapAnalysisResponse(response: string): {
 }
 
 export function parseToolGenerationResponse(response: string): GeneratedTool | null {
-  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  const jsonMatch = /\{[\s\S]*\}/.exec(response);
   if (!jsonMatch) {
     return null;
   }
@@ -270,7 +268,7 @@ export function parseToolGenerationResponse(response: string): GeneratedTool | n
 }
 
 export function parseValidationResponse(response: string): ToolValidationResult | null {
-  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  const jsonMatch = /\{[\s\S]*\}/.exec(response);
   if (!jsonMatch) {
     return null;
   }
@@ -280,18 +278,10 @@ export function parseValidationResponse(response: string): ToolValidationResult
 
     return {
       isValid: Boolean(parsed.isValid),
-      securityIssues: Array.isArray(parsed.securityIssues)
-        ? parsed.securityIssues.map(String)
-        : [],
-      logicIssues: Array.isArray(parsed.logicIssues)
-        ? parsed.logicIssues.map(String)
-        : [],
-      edgeCases: Array.isArray(parsed.edgeCases)
-        ? parsed.edgeCases.map(String)
-        : [],
-      suggestions: Array.isArray(parsed.suggestions)
-        ? parsed.suggestions.map(String)
-        : [],
+      securityIssues: Array.isArray(parsed.securityIssues) ? parsed.securityIssues.map(String) : [],
+      logicIssues: Array.isArray(parsed.logicIssues) ? parsed.logicIssues.map(String) : [],
+      edgeCases: Array.isArray(parsed.edgeCases) ? parsed.edgeCases.map(String) : [],
+      suggestions: Array.isArray(parsed.suggestions) ? parsed.suggestions.map(String) : [],
       testResults: Array.isArray(parsed.testResults)
         ? parsed.testResults.map((tr: Record<string, unknown>) => ({
             input: tr.input,

package/src/tool-generation/tool-generator.ts

@@ -6,7 +6,7 @@ import type {
   ToolValidationResult,
   ToolSelfGenerationConfig,
 } from '@cogitator-ai/types';
-import type { ZodType } from 'zod';
+import { z, type ZodType } from 'zod';
 import { ToolValidator } from './tool-validator';
 import {
   TOOL_GENERATION_SYSTEM_PROMPT,
@@ -119,7 +119,7 @@ export class ToolGenerator {
   async generateQuick(
     description: string,
     name: string,
-    parameters: Record<string, unknown>
+    _parameters: Record<string, unknown>
   ): Promise<GeneratedTool | null> {
     const gap: CapabilityGap = {
       id: `quick_${Date.now()}`,
@@ -150,10 +150,13 @@ export class ToolGenerator {
       allowedModules: this.config.sandboxConfig?.allowedModules,
     });
 
-    const response = await this.callLLM([
-      { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
-      { role: 'user', content: prompt },
-    ], 0.4);
+    const response = await this.callLLM(
+      [
+        { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
+        { role: 'user', content: prompt },
+      ],
+      0.4
+    );
 
     const tool = parseToolGenerationResponse(response.content);
 
@@ -175,10 +178,13 @@ export class ToolGenerator {
   ): Promise<GeneratedTool | null> {
     const prompt = buildToolImprovementPrompt(tool, validationResult, iteration);
 
-    const response = await this.callLLM([
-      { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
-      { role: 'user', content: prompt },
-    ], 0.3);
+    const response = await this.callLLM(
+      [
+        { role: 'system', content: TOOL_GENERATION_SYSTEM_PROMPT },
+        { role: 'user', content: prompt },
+      ],
+      0.3
+    );
 
     const improved = parseToolGenerationResponse(response.content);
 
@@ -198,7 +204,6 @@ export class ToolGenerator {
 
   createExecutableTool(generated: GeneratedTool): Tool {
     const execute = this.compileImplementation(generated.implementation);
-    const { z } = require('zod');
 
     return {
       name: generated.name,
@@ -216,10 +221,9 @@ export class ToolGenerator {
     };
   }
 
-  private compileImplementation(
-    implementation: string
-  ): (params: unknown) => Promise<unknown> {
+  private compileImplementation(implementation: string): (params: unknown) => Promise<unknown> {
     return async (params: unknown): Promise<unknown> => {
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval
       const factory = new Function(`
         "use strict";
         ${implementation}