noormme 1.1.0 → 1.2.0

package/dist/esm/agentic/improvement/RuleEngine.js

@@ -20,7 +20,7 @@ export class RuleEngine {
      */
     async defineRule(tableName, operation, action, options = {}) {
         return await this.db.transaction().execute(async (trx) => {
-            const rule = await trx
+            const rule = (await trx
                 .insertInto(this.rulesTable)
                 .values({
                 table_name: tableName,
@@ -31,10 +31,10 @@ export class RuleEngine {
                 script: options.script || null,
                 is_enabled: true,
                 metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-                created_at: new Date()
+                created_at: new Date(),
             })
                 .returningAll()
-                .executeTakeFirstOrThrow();
+                .executeTakeFirstOrThrow());
             return this.parseRule(rule);
         });
     }
@@ -51,7 +51,7 @@ export class RuleEngine {
                 return {
                     action: rule.action,
                     ruleId: rule.id,
-                    reason: `Matched rule ${rule.id} (${rule.action})`
+                    reason: `Matched rule ${rule.id} (${rule.action})`,
                 };
             }
         }
@@ -80,13 +80,10 @@ export class RuleEngine {
             .selectFrom(this.rulesTable)
             .selectAll()
             .where('table_name', '=', tableName)
-            .where((eb) => eb.or([
-            eb('operation', '=', operation),
-            eb('operation', '=', 'all')
-        ]))
+            .where((eb) => eb.or([eb('operation', '=', operation), eb('operation', '=', 'all')]))
             .where('is_enabled', '=', true)
             .execute();
-        return list.map(r => this.parseRule(r));
+        return list.map((r) => this.parseRule(r));
     }
     evaluateCondition(condition, data) {
         // Simple condition parser: "key op value"
@@ -105,12 +102,18 @@ export class RuleEngine {
         if (compareValue === 'false')
             compareValue = false;
         switch (op) {
-            case '==': return val == compareValue;
-            case '!=': return val != compareValue;
-            case '>': return val > compareValue;
-            case '<': return val < compareValue;
-            case 'includes': return String(val).includes(String(compareValue));
-            default: return false;
+            case '==':
+                return val == compareValue;
+            case '!=':
+                return val != compareValue;
+            case '>':
+                return val > compareValue;
+            case '<':
+                return val < compareValue;
+            case 'includes':
+                return String(val).includes(String(compareValue));
+            default:
+                return false;
         }
     }
     parseRule(r) {
@@ -122,8 +125,10 @@ export class RuleEngine {
             action: r.action,
             priority: r.priority,
             isEnabled: !!r.is_enabled,
-            metadata: typeof r.metadata === 'string' ? JSON.parse(r.metadata) : (r.metadata || {}),
-            createdAt: new Date(r.created_at)
+            metadata: typeof r.metadata === 'string'
+                ? JSON.parse(r.metadata)
+                : r.metadata || {},
+            createdAt: new Date(r.created_at),
         };
     }
 }

package/dist/esm/agentic/improvement/SelfEvolution.js

@@ -19,7 +19,8 @@ export class SelfEvolution {
         this.config = config;
         this.evolution = new SchemaEvolutionHelper(db);
         this.typeGenerator = new TypeGenerator(config.introspection);
-        this.snapshotsTable = config.agentic?.metadata?.snapshotsTable || 'agent_snapshots';
+        this.snapshotsTable =
+            config.agentic?.metadata?.snapshotsTable || 'agent_snapshots';
     }
     /**
      * Ensure core agentic tables have telemetry columns like 'accessed_at'
@@ -30,13 +31,16 @@ export class SelfEvolution {
             this.config.agentic?.messagesTable || 'agent_messages',
             this.config.agentic?.memoriesTable || 'agent_memories',
             this.config.agentic?.goalsTable || 'agent_goals',
-            this.config.agentic?.knowledgeTable || 'agent_knowledge_base'
+            this.config.agentic?.knowledgeTable || 'agent_knowledge_base',
         ];
         for (const table of tables) {
             try {
                 const introspector = this.db.introspection;
-                const tableInfo = await introspector.getTables().then(ts => ts.find(t => t.name === table));
-                if (tableInfo && !tableInfo.columns.some(c => c.name === 'accessed_at')) {
+                const tableInfo = await introspector
+                    .getTables()
+                    .then((ts) => ts.find((t) => t.name === table));
+                if (tableInfo &&
+                    !tableInfo.columns.some((c) => c.name === 'accessed_at')) {
                     console.log(`[SelfEvolution] Adding 'accessed_at' column to ${table}`);
                     await sql `ALTER TABLE ${sql.table(table)} ADD COLUMN accessed_at TIMESTAMP`.execute(this.db);
                 }
@@ -107,9 +111,9 @@ export class SelfEvolution {
                 ...options.metadata,
                 ddl,
                 is_auto: true,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             }),
-            created_at: new Date()
+            created_at: new Date(),
         })
             .execute();
         // 2. Regenerate types
@@ -123,13 +127,13 @@ export class SelfEvolution {
         const introspector = this.db.introspection;
         const tables = await introspector.getTables();
         const schemaInfo = {
-            tables: tables.map(t => ({
+            tables: tables.map((t) => ({
                 name: t.name,
                 columns: t.columns || [],
                 indexes: t.indexes || [],
-                foreignKeys: t.foreignKeys || []
+                foreignKeys: t.foreignKeys || [],
             })),
-            relationships: []
+            relationships: [],
         };
         const generated = this.typeGenerator.generateTypes(schemaInfo);
         if (this.config.agentic?.metadata?.typesOutputPath) {
@@ -153,12 +157,12 @@ export class SelfEvolution {
         if (ctx.includes('slow') || ctx.includes('latency')) {
             // Suggest index for metrics if they seem slow
             if (ctx.includes('metrics')) {
-                await this.evolve("CREATE INDEX IF NOT EXISTS idx_metrics_fast_lookup ON agent_metrics(metric_name, created_at)");
+                await this.evolve('CREATE INDEX IF NOT EXISTS idx_metrics_fast_lookup ON agent_metrics(metric_name, created_at)');
                 return true;
             }
             // Suggest index for memories if semantic search is mentioned
             if (ctx.includes('search') || ctx.includes('memory')) {
-                await this.evolve("CREATE INDEX IF NOT EXISTS idx_memories_session_time ON agent_memories(session_id, created_at)");
+                await this.evolve('CREATE INDEX IF NOT EXISTS idx_memories_session_time ON agent_memories(session_id, created_at)');
                 return true;
             }
         }
@@ -168,16 +172,16 @@ export class SelfEvolution {
      * Get history of evolutions
      */
     async getEvolutionHistory(limit = 10) {
-        const list = await this.db
+        const list = (await this.db
             .selectFrom(this.snapshotsTable)
             .selectAll()
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(s => ({
+            .execute());
+        return list.map((s) => ({
             ...s,
             metadata: typeof s.metadata === 'string' ? JSON.parse(s.metadata) : s.metadata,
-            createdAt: new Date(s.createdAt)
+            createdAt: new Date(s.createdAt),
         }));
     }
     /**
@@ -185,14 +189,16 @@ export class SelfEvolution {
      */
     async rollbackToSnapshot(name) {
         console.log(`[SelfEvolution] Initiating structural rollback to: ${name}`);
-        const snapshot = await this.db
+        const snapshot = (await this.db
             .selectFrom(this.snapshotsTable)
             .selectAll()
             .where('name', '=', name)
-            .executeTakeFirst();
+            .executeTakeFirst());
         if (!snapshot)
             throw new Error(`Snapshot ${name} not found.`);
-        const metadata = typeof snapshot.metadata === 'string' ? JSON.parse(snapshot.metadata) : (snapshot.metadata || {});
+        const metadata = typeof snapshot.metadata === 'string'
+            ? JSON.parse(snapshot.metadata)
+            : snapshot.metadata || {};
         if (metadata.ddl) {
             const inverse = this.invertDDL(metadata.ddl);
             if (inverse) {

package/dist/esm/agentic/improvement/SelfTestRegistry.js

@@ -23,11 +23,11 @@ export class SelfTestRegistry {
             name,
             script,
             expected_outcome: expectedOutcome,
-            created_at: new Date()
+            created_at: new Date(),
         })
             .onConflict((oc) => oc.column('name').doUpdateSet({
             script,
-            expected_outcome: expectedOutcome
+            expected_outcome: expectedOutcome,
         }))
             .execute();
     }
@@ -35,10 +35,10 @@ export class SelfTestRegistry {
      * Run all registered probes
      */
     async runAllProbes() {
-        const probes = await this.db
+        const probes = (await this.db
             .selectFrom('agent_logic_probes')
             .selectAll()
-            .execute();
+            .execute());
         const results = [];
         for (const probe of probes) {
             console.log(`[SelfTestRegistry] Running probe: ${probe.name}`);
@@ -59,9 +59,9 @@ export class SelfTestRegistry {
                                 this.config.memoriesTable || 'agent_memories',
                                 this.config.knowledgeTable || 'agent_knowledge_base',
                                 this.config.actionsTable || 'agent_actions',
-                                this.config.metricsTable || 'agent_metrics'
+                                this.config.metricsTable || 'agent_metrics',
                             ];
-                            const missing = requiredSubsets.filter(req => !tables.some(t => t.name === req));
+                            const missing = requiredSubsets.filter((req) => !tables.some((t) => t.name === req));
                             success = missing.length === 0;
                             break;
                         case 'check_memory_integrity':
@@ -94,47 +94,50 @@ export class SelfTestRegistry {
                             const orphanedKnowledge = await this.db
                                 .selectFrom(knowledgeTable)
                                 .where('source_session_id', 'is not', null)
-                                .where((eb) => eb.not(eb.exists(eb.selectFrom(sessionsTbl)
+                                .where((eb) => eb.not(eb.exists(eb
+                                .selectFrom(sessionsTbl)
                                 .select('id')
                                 .whereRef(`${knowledgeTable}.source_session_id`, '=', `${sessionsTbl}.id`))))
                                 .execute();
                             const orphanedActions = await this.db
                                 .selectFrom(actionsTable)
-                                .where((eb) => eb.not(eb.exists(eb.selectFrom(sessionsTbl)
+                                .where((eb) => eb.not(eb.exists(eb
+                                .selectFrom(sessionsTbl)
                                 .select('id')
                                 .whereRef(`${actionsTable}.session_id`, '=', `${sessionsTbl}.id`))))
                                 .execute();
-                            success = orphanedKnowledge.length === 0 && orphanedActions.length === 0;
+                            success =
+                                orphanedKnowledge.length === 0 && orphanedActions.length === 0;
                             break;
                         case 'check_performance_drift':
                             // Real check: Compare last 10 queries average with historical baseline
                             const metricsTbl = this.config.metricsTable || 'agent_metrics';
-                            const recentMetrics = await this.db
+                            const recentMetrics = (await this.db
                                 .selectFrom(metricsTbl)
                                 .select('execution_time')
                                 .orderBy('created_at', 'desc')
                                 .limit(20)
-                                .execute();
+                                .execute());
                             if (recentMetrics.length < 5) {
                                 success = true; // Not enough data to determine drift
                             }
                             else {
                                 const avgRecent = recentMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / recentMetrics.length;
                                 // Baseline: Avg of previous 100 metrics excluding the most recent 20
-                                const baselineMetrics = await this.db
+                                const baselineMetrics = (await this.db
                                     .selectFrom(metricsTbl)
                                     .select('execution_time')
                                     .orderBy('created_at', 'desc')
                                     .offset(20)
                                     .limit(100)
-                                    .execute();
+                                    .execute());
                                 if (baselineMetrics.length === 0) {
                                     success = avgRecent < 500; // Fallback threshold (500ms)
                                 }
                                 else {
                                     const avgBaseline = baselineMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / baselineMetrics.length;
                                     // Fail if recent performance is > 50% worse than baseline
-                                    success = avgRecent < (avgBaseline * 1.5);
+                                    success = avgRecent < avgBaseline * 1.5;
                                 }
                             }
                             break;
@@ -151,7 +154,7 @@ export class SelfTestRegistry {
                     .updateTable('agent_logic_probes')
                     .set({
                     last_run: new Date(),
-                    last_status: success ? 'pass' : 'fail'
+                    last_status: success ? 'pass' : 'fail',
                 })
                     .where('id', '=', probe.id)
                     .execute();

package/dist/esm/agentic/improvement/SkillSynthesizer.js

@@ -23,15 +23,16 @@ class AISynthesisStrategy {
                 if (!model) {
                     console.warn(`[SkillSynthesizer] No LLMProvider available. Skipping synthesis.`);
                     return {
-                        mutatedDescription: context.existingDescription || 'Unmodified skill (Synthesis skipped: No LLM)',
+                        mutatedDescription: context.existingDescription ||
+                            'Unmodified skill (Synthesis skipped: No LLM)',
                         mutatedMetadata: { synthesis_status: 'skipped_no_llm' },
-                        version: `1.0.${Date.now()}`
+                        version: `1.0.${Date.now()}`,
                     };
                 }
                 const response = await model.complete({
                     prompt,
                     responseFormat: 'json',
-                    temperature: 0.3
+                    temperature: 0.3,
                 });
                 if (response.usage) {
                     this.synthesizer.totalTokensConsumed += response.usage.totalTokens;
@@ -42,10 +43,12 @@ class AISynthesisStrategy {
                         mutatedDescription: parsed.description || context.existingDescription,
                         mutatedMetadata: {
                             ...parsed.metadata,
-                            synthesis_engine: this.cortex.llmPremium ? 'Tiered-Premium' : 'Production-LLM',
-                            failure_context_size: context.failures.length
+                            synthesis_engine: this.cortex.llmPremium
+                                ? 'Tiered-Premium'
+                                : 'Production-LLM',
+                            failure_context_size: context.failures.length,
                         },
-                        version: `1.0.${Date.now()}`
+                        version: `1.0.${Date.now()}`,
                     };
                 }
                 catch (err) {
@@ -56,7 +59,7 @@ class AISynthesisStrategy {
                 attempts++;
                 if (attempts >= maxRetries)
                     throw error;
-                await new Promise(resolve => setTimeout(resolve, 1000 * attempts));
+                await new Promise((resolve) => setTimeout(resolve, 1000 * attempts));
             }
         }
         throw new Error('Synthesis failed after maximum retries');
@@ -72,12 +75,14 @@ class AISynthesisStrategy {
             You are a Meta-Evolutionary AI Engine optimizing multiple tools in parallel.
             
             TOOLS TO MUTATE:
-            ${contexts.map((ctx, i) => `
+            ${contexts
+            .map((ctx, i) => `
                 [Tool ${i + 1}: ${ctx.targetTool}]
                 Current Description: ${ctx.existingDescription || 'None'}
                 Failure Patterns:
-                ${ctx.failures.map(f => `- Args: ${JSON.stringify(f.arguments)}, Error: ${f.error}`).join('\n')}
-            `).join('\n')}
+                ${ctx.failures.map((f) => `- Args: ${JSON.stringify(f.arguments)}, Error: ${f.error}`).join('\n')}
+            `)
+            .join('\n')}
 
             TASK:
             For each tool, provide a mutation as a JSON array of objects:
@@ -93,20 +98,20 @@ class AISynthesisStrategy {
         const response = await model.complete({
             prompt: batchPrompt,
             responseFormat: 'json',
-            temperature: 0.2
+            temperature: 0.2,
         });
         if (response.usage) {
             this.synthesizer.totalTokensConsumed += response.usage.totalTokens;
         }
         try {
             const parsed = JSON.parse(response.content);
-            return parsed.map(item => ({
+            return parsed.map((item) => ({
                 tool: item.tool,
                 mutation: {
                     mutatedDescription: item.description,
                     mutatedMetadata: item.metadata,
-                    version: `1.0.${Date.now()}`
-                }
+                    version: `1.0.${Date.now()}`,
+                },
             }));
         }
         catch (err) {
@@ -114,7 +119,9 @@ class AISynthesisStrategy {
         }
     }
     buildMutationPrompt(context) {
-        const failureList = context.failures.map((f, i) => `${i + 1}. Args: ${JSON.stringify(f.arguments)}, Error: ${f.error || 'None'}`).join('\n');
+        const failureList = context.failures
+            .map((f, i) => `${i + 1}. Args: ${JSON.stringify(f.arguments)}, Error: ${f.error || 'None'}`)
+            .join('\n');
         return `
             You are a Meta-Evolutionary AI Engine optimizing a tool: "${context.targetTool}".
             Analyze FAILURES and rewrite the description to prevent them.
@@ -147,7 +154,7 @@ export class SkillSynthesizer {
             rollbackThresholdZ: 2.5,
             enableHiveLink: true,
             mutationAggressiveness: 0.5,
-            maxSandboxSkills: 5
+            maxSandboxSkills: 5,
         };
         this.actionsTable = config.actionsTable || 'agent_actions';
         this.strategy = new AISynthesisStrategy(this.cortex, this);
@@ -158,7 +165,7 @@ export class SkillSynthesizer {
      */
     async preWarmSkill(name) {
         const capability = await this.cortex.capabilities.getCapabilities('experimental');
-        const target = capability.find(c => c.name === name);
+        const target = capability.find((c) => c.name === name);
         if (!target)
             return;
         // Synthesis pre-run to ensure 'Verified' description is optimized before status change
@@ -166,14 +173,19 @@ export class SkillSynthesizer {
             targetTool: target.name,
             failures: [], // No recent failures, just optimizing for permanence
             existingDescription: target.description,
-            evolutionConfig: this.evolutionConfig
+            evolutionConfig: this.evolutionConfig,
         });
         await this.db
-            .updateTable(this.cortex.agenticConfig.capabilitiesTable || 'agent_capabilities')
+            .updateTable(this.cortex.agenticConfig.capabilitiesTable ||
+            'agent_capabilities')
             .set({
             description: mutation.mutatedDescription,
-            metadata: JSON.stringify({ ...target.metadata, pre_warmed: true, pre_warmed_at: new Date() }),
-            updated_at: new Date()
+            metadata: JSON.stringify({
+                ...target.metadata,
+                pre_warmed: true,
+                pre_warmed_at: new Date(),
+            }),
+            updated_at: new Date(),
         })
             .where('name', '=', name)
             .execute();
@@ -216,12 +228,14 @@ export class SkillSynthesizer {
             const contexts = await Promise.all(items.map(async (item) => {
                 return {
                     targetTool: item.tool,
-                    failures: item.failures.map(f => ({
-                        arguments: typeof f.arguments === 'string' ? JSON.parse(f.arguments) : f.arguments,
+                    failures: item.failures.map((f) => ({
+                        arguments: typeof f.arguments === 'string'
+                            ? JSON.parse(f.arguments)
+                            : f.arguments,
                         error: f.outcome,
-                        timestamp: new Date(f.created_at)
+                        timestamp: new Date(f.created_at),
                     })),
-                    evolutionConfig: this.evolutionConfig
+                    evolutionConfig: this.evolutionConfig,
                 };
             }));
             if (items.length > 1 && (this.cortex.llmFast || this.cortex.llm)) {
@@ -249,7 +263,7 @@ export class SkillSynthesizer {
             mutatedFrom: tool,
             synthesis_engine: 'Ultra-Scale-Tiered',
             ...mutation.mutatedMetadata,
-            synthesized_at: new Date()
+            synthesized_at: new Date(),
         });
     }
     async pruneSandboxIfNeeded() {
@@ -261,7 +275,8 @@ export class SkillSynthesizer {
                 .slice(0, Math.ceil(experimental.length * 0.2));
             for (const skill of toPrune) {
                 await this.db
-                    .deleteFrom(this.cortex.agenticConfig.capabilitiesTable || 'agent_capabilities')
+                    .deleteFrom(this.cortex.agenticConfig.capabilitiesTable ||
+                    'agent_capabilities')
                     .where('id', '=', skill.id)
                     .execute();
             }

package/dist/esm/agentic/improvement/SovereignMetrics.js

@@ -19,7 +19,7 @@ export class SovereignMetrics {
      * Record a metric point
      */
     async recordMetric(metricName, metricValue, options = {}) {
-        const metric = await this.db
+        const metric = (await this.db
             .insertInto(this.metricsTable)
             .values({
             session_id: options.sessionId ?? null,
@@ -28,10 +28,10 @@ export class SovereignMetrics {
             metric_value: metricValue,
             unit: options.unit ?? null,
             metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-            created_at: new Date()
+            created_at: new Date(),
         })
             .returningAll()
-            .executeTakeFirstOrThrow();
+            .executeTakeFirstOrThrow());
         return this.parseMetric(metric);
     }
     /**
@@ -55,7 +55,7 @@ export class SovereignMetrics {
             eb.fn.min('metric_value').as('min'),
             eb.fn.max('metric_value').as('max'),
             eb.fn.avg('metric_value').as('avg'),
-            eb.fn.count('id').as('count')
+            eb.fn.count('id').as('count'),
         ])
             .where('metric_name', '=', metricName);
         if (options.agentId) {
@@ -64,51 +64,51 @@ export class SovereignMetrics {
         if (options.sessionId) {
             query = query.where('session_id', '=', options.sessionId);
         }
-        const result = await query.executeTakeFirst();
+        const result = (await query.executeTakeFirst());
         return {
             min: Number(result?.min || 0),
             max: Number(result?.max || 0),
             avg: Number(result?.avg || 0),
-            count: Number(result?.count || 0)
+            count: Number(result?.count || 0),
         };
     }
     /**
      * Get recent metrics for analysis
      */
     async getRecentMetrics(limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     /**
      * Get metrics filtered by agent ID.
      */
     async getMetricsByAgent(agentId, limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('agent_id', '=', agentId)
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     /**
      * Get metrics filtered by session ID.
      */
     async getMetricsBySession(sessionId, limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('session_id', '=', sessionId)
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     parseMetric(m) {
         return {
@@ -118,8 +118,10 @@ export class SovereignMetrics {
             metricName: m.metric_name,
             metricValue: m.metric_value,
             unit: m.unit,
-            metadata: typeof m.metadata === 'string' ? JSON.parse(m.metadata) : (m.metadata || {}),
-            createdAt: new Date(m.created_at)
+            metadata: typeof m.metadata === 'string'
+                ? JSON.parse(m.metadata)
+                : m.metadata || {},
+            createdAt: new Date(m.created_at),
         };
     }
 }