noormme 1.2.3 → 1.2.5

package/dist/esm/agentic/improvement/strategy/MutationEngine.js

@@ -0,0 +1,116 @@
+/// <reference types="./MutationEngine.d.ts" />
+export class MutationEngine {
+    personasTable;
+    constructor(personasTable) {
+        this.personasTable = personasTable;
+    }
+    async applyMutation(db, cortex, persona, report, failures = [], sanitizeRoleFn, parsePersonaFn) {
+        return await db.transaction().execute(async (trx) => {
+            const reason = failures.length > 0 ? `Failure Patterns: ${failures.join(', ')}` : report.recommendation;
+            let updates = {};
+            let mutationType = 'role_update';
+            if (failures.length > 0) {
+                const lessons = await cortex.reasoner.synthesizeLessons(trx);
+                const relevantLessons = (lessons['general'] || []).slice(0, 2);
+                updates = {
+                    role: `${persona.role || ''} (Optimized for: ${failures.join(', ')}. Patterns: ${relevantLessons.join('; ')})`.trim(),
+                };
+            }
+            else {
+                const allPersonas = await trx.selectFrom(this.personasTable).selectAll().execute();
+                const winningMutations = allPersonas
+                    .map((p) => parsePersonaFn(p))
+                    .filter((p) => (p.metadata?.evolution_status === 'stable' || !p.metadata?.evolution_status) && p.metadata?.mutation_reason?.includes(report.recommendation));
+                if (winningMutations.length > 0) {
+                    const sorted = winningMutations.sort((a, b) => (b.metadata?.anchored_reliability || 0) - (a.metadata?.anchored_reliability || 0));
+                    const alphaMatch = sorted[0];
+                    updates = { role: sanitizeRoleFn(alphaMatch.role || persona.role || 'Agent') };
+                }
+                else {
+                    switch (report.recommendation) {
+                        case 'optimize_accuracy':
+                            updates = { role: sanitizeRoleFn(`${persona.role || ''} (Focus strictly on accuracy and detailed verification)`) };
+                            break;
+                        case 'optimize_efficiency':
+                            updates = { policies: [...(persona.policies || []), 'timeout_reduction', 'concise_output'] };
+                            mutationType = 'policy_update';
+                            break;
+                        case 'critical_intervention':
+                            return await this.rollback(db, persona.id, parsePersonaFn);
+                        default:
+                            return null;
+                    }
+                }
+            }
+            if (updates.role)
+                updates.role = sanitizeRoleFn(updates.role);
+            // Conflict Detection
+            const contradictions = await cortex.reasoner.detectContradictions(trx);
+            for (const contradiction of contradictions) {
+                if (updates.role && contradiction.includes(updates.role.slice(0, 20)))
+                    return null;
+            }
+            const mutation = {
+                id: `mut_${Date.now()}`,
+                timestamp: Date.now(),
+                type: mutationType,
+                previousState: { role: persona.role, policies: persona.policies, capabilities: persona.capabilities },
+                newState: { ...updates },
+                reason: `Auto-mutation triggered by ${report.recommendation}`,
+            };
+            const history = [...(persona.metadata?.mutationHistory || []), mutation].slice(-5);
+            const newMetadata = {
+                ...persona.metadata,
+                mutationHistory: history,
+                evolution_status: 'verifying',
+                mutation_reason: report.recommendation,
+                verification_started_at: Date.now(),
+                verification_baseline: { successRate: report.successRate, averageLatency: report.averageLatency },
+            };
+            await trx.updateTable(this.personasTable)
+                .set({
+                role: updates.role || persona.role,
+                policies: updates.policies ? JSON.stringify(updates.policies) : undefined,
+                capabilities: updates.capabilities ? JSON.stringify(updates.capabilities) : undefined,
+                metadata: JSON.stringify(newMetadata),
+                updated_at: new Date(),
+            })
+                .where('id', '=', persona.id)
+                .execute();
+            return `Persona ${persona.id} mutated and entering verification window.`;
+        });
+    }
+    async rollback(db, id, parsePersonaFn) {
+        return await db.transaction().execute(async (trx) => {
+            const current = await trx.selectFrom(this.personasTable).selectAll().where('id', '=', id).executeTakeFirst();
+            if (!current)
+                throw new Error(`Persona ${id} not found`);
+            const persona = parsePersonaFn(current);
+            const history = persona.metadata?.mutationHistory || [];
+            const lastMutation = history.pop();
+            if (!lastMutation)
+                return `No mutations to rollback for persona ${id}`;
+            const previous = lastMutation.previousState;
+            const rollbackHistory = [...(persona.metadata?.rollbackHistory || []), Date.now()];
+            const newMetadata = {
+                ...persona.metadata,
+                mutationHistory: history,
+                rollbackHistory: rollbackHistory,
+                last_failed_mutation: { type: lastMutation.type, timestamp: Date.now() },
+                evolution_status: 'stable',
+                lastRollback: Date.now(),
+            };
+            await trx.updateTable(this.personasTable)
+                .set({
+                role: previous.role,
+                policies: previous.policies ? JSON.stringify(previous.policies) : undefined,
+                capabilities: previous.capabilities ? JSON.stringify(previous.capabilities) : undefined,
+                metadata: JSON.stringify(newMetadata),
+                updated_at: new Date(),
+            })
+                .where('id', '=', id)
+                .execute();
+            return `Rolled back mutation ${lastMutation.id} for persona ${id}`;
+        });
+    }
+}

package/dist/esm/agentic/improvement/strategy/PerformanceAnalyst.d.ts

@@ -0,0 +1,6 @@
+import type { Cortex } from '../../Cortex.js';
+import type { PerformanceReport } from '../StrategicPlanner.js';
+export declare class PerformanceAnalyst {
+    analyzeFailurePatterns(cortex: Cortex, personaId: string | number, trxOrDb?: any): Promise<string[]>;
+    analyze(trxOrDb: any, cortex: Cortex, metricsTable: string, id: string | number): Promise<PerformanceReport>;
+}

package/dist/esm/agentic/improvement/strategy/PerformanceAnalyst.js

@@ -0,0 +1,81 @@
+/// <reference types="./PerformanceAnalyst.d.ts" />
+import { sql } from '../../../raw-builder/sql.js';
+export class PerformanceAnalyst {
+    async analyzeFailurePatterns(cortex, personaId, trxOrDb = cortex.db) {
+        const patterns = [];
+        try {
+            // NOTE: cortex.actions.getFailureReport might need to be transaction-aware too
+            const failureReport = await cortex.actions.getFailureReport(trxOrDb);
+            const frequentFailures = failureReport.filter((f) => f.failureCount > 1);
+            for (const fail of frequentFailures) {
+                patterns.push(`tool_failure_${fail.toolName}`);
+            }
+        }
+        catch (e) {
+            // Fallback handled by orchestrator
+        }
+        return patterns;
+    }
+    async analyze(trxOrDb, cortex, metricsTable, id) {
+        const recentMetrics = await trxOrDb
+            .selectFrom(metricsTable)
+            .selectAll()
+            .where((eb) => eb.or([
+            eb(sql `json_extract(metadata, '$.persona_id')`, '=', id),
+            eb(sql `metadata->>'persona_id'`, '=', String(id)),
+        ]))
+            .orderBy('created_at', 'desc')
+            .limit(50)
+            .execute();
+        const globalMetrics = await cortex.metrics.getRecentMetrics(200, trxOrDb);
+        const calcStats = (metricName) => {
+            const vals = globalMetrics
+                .filter((m) => m.metricName === metricName)
+                .map((m) => Number(m.metricValue));
+            if (vals.length < 10)
+                return { mean: metricName === 'query_latency' ? 500 : 0.9, stdDev: 0.1 };
+            const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+            const variance = vals.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / vals.length;
+            return { mean, stdDev: Math.sqrt(variance) || 0.05 };
+        };
+        const successStats = calcStats('task_success_rate');
+        const latencyStats = calcStats('query_latency');
+        if (recentMetrics.length === 0) {
+            return {
+                personaId: id,
+                successRate: successStats.mean,
+                averageLatency: latencyStats.mean,
+                sampleSize: 0,
+                recommendation: 'maintain',
+            };
+        }
+        const successMetrics = recentMetrics.filter((m) => m.metric_name === 'task_success_rate');
+        const latencyMetrics = recentMetrics.filter((m) => m.metric_name === 'query_latency');
+        const avgSuccess = successMetrics.length > 0
+            ? successMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / successMetrics.length
+            : successStats.mean;
+        const avgLatency = latencyMetrics.length > 0
+            ? latencyMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / latencyMetrics.length
+            : latencyStats.mean;
+        let recommendation = 'maintain';
+        const criticalThreshold = successStats.mean - 2.5 * successStats.stdDev;
+        const accuracyThreshold = successStats.mean - 1.0 * successStats.stdDev;
+        const efficiencyThreshold = latencyStats.mean + 2.0 * latencyStats.stdDev;
+        if (avgSuccess < criticalThreshold) {
+            recommendation = 'critical_intervention';
+        }
+        else if (avgSuccess < accuracyThreshold) {
+            recommendation = 'optimize_accuracy';
+        }
+        else if (avgLatency > efficiencyThreshold) {
+            recommendation = 'optimize_efficiency';
+        }
+        return {
+            personaId: id,
+            successRate: avgSuccess,
+            averageLatency: avgLatency,
+            sampleSize: recentMetrics.length,
+            recommendation,
+        };
+    }
+}

package/dist/esm/agentic/util/db-utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility function to apply a "FOR UPDATE" lock only where supported (Not in SQLite)
+ */
+export declare function withLock(query: any, trx: any): any;

package/dist/esm/agentic/util/db-utils.js

@@ -0,0 +1,25 @@
+/// <reference types="./db-utils.d.ts" />
+/**
+ * Utility function to apply a "FOR UPDATE" lock only where supported (Not in SQLite)
+ */
+export function withLock(query, trx) {
+    if (!trx || typeof trx.getExecutor !== 'function') {
+        // If we're using a mock or a version of Kysely without getExecutor
+        // we default to no lock to prevent failures in tests
+        return query;
+    }
+    try {
+        const executor = trx.getExecutor();
+        const adapterName = executor?.adapter?.constructor?.name ||
+            executor?.dialect?.constructor?.name ||
+            '';
+        if (adapterName.toLowerCase().includes('sqlite')) {
+            return query;
+        }
+    }
+    catch (error) {
+        // Fallback if execution fails for some reason
+        return query;
+    }
+    return query.forUpdate();
+}

package/dist/esm/helpers/agent-schema.js

@@ -117,6 +117,7 @@ export class AgentSchemaHelper {
             .addColumn('tool_name', 'text', (col) => col.notNull())
             .addColumn('arguments', 'text', (col) => col.notNull())
             .addColumn('outcome', 'text')
+            .addColumn('error', 'text')
             .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
             .addColumn('duration_ms', 'integer')
             .addColumn('metadata', 'text')

package/dist/esm/testing/test-utils.js

@@ -89,6 +89,8 @@ export async function setupTestSchema(db) {
         .on('comments')
         .column('user_id')
         .execute();
+    // Initialize agent schema
+    await db.agent.schema.initializeSchema();
     // Initialize NOORMME to discover the schema
     // Temporarily enable warnings to see discovery errors
     const originalWarn = console.warn;

package/dist/esm/types/index.d.ts

@@ -385,6 +385,14 @@ export interface AgentPersona {
     createdAt: Date;
     updatedAt: Date;
 }
+export interface PersonaMutation {
+    id: string;
+    timestamp: number;
+    type: 'role_update' | 'policy_update' | 'capability_update';
+    previousState: Partial<AgentPersona>;
+    newState: Partial<AgentPersona>;
+    reason: string;
+}
 export interface AgentQuota {
     id: string | number;
     targetType: 'persona' | 'swarm' | 'global';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noormme",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "NOORMME - The Agentic Data Engine. High-fidelity persistence and cognitive governance for Autonomous AI Agents.",
   "repository": {
     "type": "git",
@@ -60,48 +60,6 @@
       "default": "./dist/cjs/cli/index.js"
     }
   },
-  "scripts": {
-    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
-    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:unit": "jest tests/unit",
-    "test:integration": "jest tests/integration",
-    "test:cli": "jest tests/cli",
-    "test:original": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
-    "test:node:build": "tsc -p test/node",
-    "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
-    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
-    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
-    "test:browser": "pnpm build && pnpm test:browser:build && node test/browser/test.js",
-    "test:bun": "pnpm build && bun link && cd test/bun && bun install && bun run test",
-    "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
-    "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/local.test.ts && deno run --allow-env --allow-read --allow-net --no-lock test/deno/cdn.test.ts",
-    "test:typings": "tsd test/typings",
-    "test:esmimports": "node scripts/check-esm-imports.js",
-    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
-    "test:exports": "attw --pack . && node scripts/check-exports.js",
-    "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
-    "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
-    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
-    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
-    "build:cjs": "tsc -p tsconfig-cjs.json",
-    "script:module-fixup": "node scripts/module-fixup.js",
-    "script:copy-interface-doc": "node scripts/copy-interface-documentation.js",
-    "script:add-deno-type-references": "node scripts/add-deno-type-references.js",
-    "script:align-site-version": "node --experimental-strip-types scripts/align-site-version.mts",
-    "script:generate-site-examples": "node scripts/generate-site-examples.js",
-    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
-    "prepublishOnly": "pnpm build",
-    "version": "pnpm script:align-site-version && git add .",
-    "postversion": "pnpm publish --no-git-checks",
-    "prepack": "pnpm build",
-    "postpack": "echo 'Package ready for npm publish'",
-    "publish:dry-run": "pnpm build && npm pack --dry-run",
-    "publish:check": "pnpm build && npm publish --dry-run"
-  },
   "author": "NOORMME Team",
   "license": "MIT",
   "devDependencies": {
@@ -136,7 +94,6 @@
     "tsd": "^0.33.0",
     "typescript": "~5.9.2"
   },
-  "packageManager": "pnpm@10.16.1+sha512.0e155aa2629db8672b49e8475da6226aa4bdea85fdcdfdc15350874946d4f3c91faaf64cbdc4a5d1ab8002f473d5c3fcedcd197989cf0390f9badd3c04678706",
   "dependencies": {
     "better-sqlite3": "^12.4.1",
     "chalk": "^5.0.0",
@@ -149,5 +106,44 @@
   },
   "bin": {
     "noormme": "./dist/cjs/cli/index.js"
+  },
+  "scripts": {
+    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
+    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration",
+    "test:cli": "jest tests/cli",
+    "test:original": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
+    "test:node:build": "tsc -p test/node",
+    "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
+    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
+    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
+    "test:browser": "pnpm build && pnpm test:browser:build && node test/browser/test.js",
+    "test:bun": "pnpm build && bun link && cd test/bun && bun install && bun run test",
+    "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
+    "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/local.test.ts && deno run --allow-env --allow-read --allow-net --no-lock test/deno/cdn.test.ts",
+    "test:typings": "tsd test/typings",
+    "test:esmimports": "node scripts/check-esm-imports.js",
+    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
+    "test:exports": "attw --pack . && node scripts/check-exports.js",
+    "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
+    "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
+    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
+    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
+    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
+    "build:cjs": "tsc -p tsconfig-cjs.json",
+    "script:module-fixup": "node scripts/module-fixup.js",
+    "script:copy-interface-doc": "node scripts/copy-interface-documentation.js",
+    "script:add-deno-type-references": "node scripts/add-deno-type-references.js",
+    "script:align-site-version": "node --experimental-strip-types scripts/align-site-version.mts",
+    "script:generate-site-examples": "node scripts/generate-site-examples.js",
+    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
+    "version": "pnpm script:align-site-version && git add .",
+    "postversion": "pnpm publish --no-git-checks",
+    "publish:dry-run": "pnpm build && npm pack --dry-run",
+    "publish:check": "pnpm build && npm publish --dry-run"
   }
 }