@cogitator-ai/self-modifying 0.1.0 → 1.0.0

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')}

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

@@ -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(),
@@ -336,7 +332,6 @@ export class SelfModifyingAgent {
     const activeToos = await this.toolStore.list({ status: 'active' });
     for (const tool of activeToos) {
       if (tool.validationScore && tool.validationScore > 0.8) {
-
       }
     }
 
@@ -364,7 +359,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 +415,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 },
     };
   }
@@ -451,19 +456,14 @@ 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) {
@@ -483,15 +483,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,12 +515,14 @@ 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({

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(
@@ -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')}`
@@ -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

@@ -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);
 
@@ -216,9 +222,7 @@ 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> => {
       const factory = new Function(`
         "use strict";

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

@@ -1,8 +1,4 @@
-import type {
-  ToolSandboxConfig,
-  ToolSandboxResult,
-  GeneratedTool,
-} from '@cogitator-ai/types';
+import type { ToolSandboxConfig, ToolSandboxResult, GeneratedTool } from '@cogitator-ai/types';
 
 export const DEFAULT_SANDBOX_CONFIG: ToolSandboxConfig = {
   enabled: true,
@@ -43,10 +39,7 @@ export class ToolSandbox {
     this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
   }
 
-  async execute(
-    tool: GeneratedTool,
-    params: unknown
-  ): Promise<ToolSandboxResult> {
+  async execute(tool: GeneratedTool, params: unknown): Promise<ToolSandboxResult> {
     const startTime = Date.now();
     this.logs.length = 0;
 
@@ -114,9 +107,7 @@ export class ToolSandbox {
       if (testCase.shouldThrow) {
         passed = !execResult.success;
       } else if (testCase.expectedOutput !== undefined) {
-        passed =
-          execResult.success &&
-          this.deepEqual(execResult.result, testCase.expectedOutput);
+        passed = execResult.success && this.deepEqual(execResult.result, testCase.expectedOutput);
       } else {
         passed = execResult.success;
       }
@@ -174,9 +165,7 @@ export class ToolSandbox {
 
     for (const pattern of forbidden) {
       if (pattern.test(code)) {
-        throw new Error(
-          `Security violation: forbidden pattern detected - ${pattern.source}`
-        );
+        throw new Error(`Security violation: forbidden pattern detected - ${pattern.source}`);
       }
     }
 

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

@@ -188,7 +188,10 @@ export class ToolValidator {
     if (sandboxResult.failed > 0) {
       const failedTests = sandboxResult.results.filter((r) => !r.passed);
       logicIssues.push(
-        ...failedTests.map((t) => `Test failed for input ${JSON.stringify(t.input)}: ${t.error || 'unexpected output'}`)
+        ...failedTests.map(
+          (t) =>
+            `Test failed for input ${JSON.stringify(t.input)}: ${t.error || 'unexpected output'}`
+        )
       );
     }
 
@@ -266,15 +269,18 @@ export class ToolValidator {
         }))
       );
 
-      const response = await this.callLLM([
-        {
-          role: 'system',
-          content: `You are a security auditor and code reviewer.
+      const response = await this.callLLM(
+        [
+          {
+            role: 'system',
+            content: `You are a security auditor and code reviewer.
 Analyze code for security vulnerabilities, logic errors, and edge cases.
 Be thorough but practical - focus on real issues.`,
-        },
-        { role: 'user', content: prompt },
-      ], 0.2);
+          },
+          { role: 'user', content: prompt },
+        ],
+        0.2
+      );
 
       return response ? parseValidationResponse(response.content) : null;
     } catch {
@@ -285,15 +291,13 @@ Be thorough but practical - focus on real issues.`,
   private generateBasicTestCases(
     tool: GeneratedTool
   ): Array<{ input: unknown; expectedOutput?: unknown; shouldThrow?: boolean }> {
-    const testCases: Array<{ input: unknown; expectedOutput?: unknown; shouldThrow?: boolean }> = [];
+    const testCases: Array<{ input: unknown; expectedOutput?: unknown; shouldThrow?: boolean }> =
+      [];
     const params = tool.parameters;
 
     if (params.type === 'object' && params.properties) {
       const validInput: Record<string, unknown> = {};
-      const properties = params.properties as Record<
-        string,
-        { type?: string; default?: unknown }
-      >;
+      const properties = params.properties as Record<string, { type?: string; default?: unknown }>;
 
       for (const [key, schema] of Object.entries(properties)) {
         validInput[key] = this.generateSampleValue(schema.type, schema.default);