mengram-ai 2.6.1 → 2.7.0

package/README.md

@@ -38,6 +38,15 @@ const all = await m.searchAll('deployment issues');
 // Procedure feedback — AI learns what works
 await m.procedureFeedback(procId, { success: true });
 
+// Experience-driven evolution — procedure improves on failure
+await m.procedureFeedback(procId, {
+  success: false, context: 'OOM on step 3', failedAtStep: 3
+});
+
+// View procedure version history
+const history = await m.procedureHistory(procId);
+// → { versions: [v1, v2, v3], evolution_log: [...] }
+
 // Cognitive Profile — instant personalization
 const profile = await m.getProfile('ali');
 // → { system_prompt: "You are talking to Ali, a developer..." }
@@ -46,7 +55,7 @@ const profile = await m.getProfile('ali');
 ## TypeScript
 
 ```typescript
-import { MengramClient, SearchResult, Episode, Procedure, UnifiedSearchResult } from 'mengram-ai';
+import { MengramClient, SearchResult, Episode, Procedure, UnifiedSearchResult, ProcedureHistoryResult } from 'mengram-ai';
 
 const m = new MengramClient('om-...');
 
@@ -66,7 +75,9 @@ const all: UnifiedSearchResult = await m.searchAll('issues');
 | `searchAll(query, options?)` | **Unified search (all 3 types)** |
 | `episodes(options?)` | **Search/list episodic memories** |
 | `procedures(options?)` | **Search/list procedural memories** |
-| `procedureFeedback(id, options?)` | **Record success/failure** |
+| `procedureFeedback(id, options?)` | **Record success/failure (triggers evolution on failure)** |
+| `procedureHistory(id)` | **Version history + evolution log** |
+| `procedureEvolution(id)` | **Evolution log (what changed and why)** |
 | `getProfile(userId?, options?)` | **Cognitive Profile** |
 | `getAll(options?)` | List all memories |
 | `get(name)` | Get specific entity |

package/index.d.ts

@@ -86,6 +86,8 @@ export interface Episode {
   participants: string[];
   emotional_valence: 'positive' | 'negative' | 'neutral' | 'mixed';
   importance: number;
+  linked_procedure_id: string | null;
+  failed_at_step: number | null;
   score?: number;
   created_at: string | null;
   memory_type?: 'episodic';
@@ -99,6 +101,10 @@ export interface Procedure {
   entity_names: string[];
   success_count: number;
   fail_count: number;
+  version: number;
+  parent_version_id?: string | null;
+  evolved_from_episode?: string | null;
+  is_current?: boolean;
   score?: number;
   last_used: string | null;
   created_at?: string | null;
@@ -106,6 +112,31 @@ export interface Procedure {
   memory_type?: 'procedural';
 }
 
+export interface ProcedureEvolutionEntry {
+  id: string;
+  procedure_id: string;
+  episode_id: string | null;
+  change_type: 'step_added' | 'step_removed' | 'step_modified' | 'step_reordered' | 'auto_created';
+  diff: Record<string, any>;
+  version_before: number;
+  version_after: number;
+  created_at: string | null;
+}
+
+export interface ProcedureHistoryResult {
+  versions: Procedure[];
+  evolution_log: ProcedureEvolutionEntry[];
+}
+
+export interface FeedbackResult {
+  id: string;
+  name: string;
+  success_count: number;
+  fail_count: number;
+  feedback: 'success' | 'failure';
+  evolution_triggered: boolean;
+}
+
 export interface UnifiedSearchResult {
   semantic: SearchResult[];
   episodic: Episode[];
@@ -149,7 +180,9 @@ export declare class MengramClient {
 
   // Procedural Memory
   procedures(options?: { query?: string; limit?: number }): Promise<Procedure[]>;
-  procedureFeedback(procedureId: string, options?: { success?: boolean }): Promise<any>;
+  procedureFeedback(procedureId: string, options?: { success?: boolean; context?: string; failedAtStep?: number }): Promise<FeedbackResult>;
+  procedureHistory(procedureId: string): Promise<ProcedureHistoryResult>;
+  procedureEvolution(procedureId: string): Promise<{ evolution: ProcedureEvolutionEntry[] }>;
 
   // Unified Search
   searchAll(query: string, options?: { limit?: number }): Promise<UnifiedSearchResult>;

package/index.js

@@ -273,18 +273,43 @@ class MengramClient {
 
   /**
    * Record success/failure feedback for a procedure.
+   * On failure with context, triggers experience-driven evolution.
    * @param {string} procedureId - UUID of the procedure
    * @param {object} [options]
    * @param {boolean} [options.success] - true if worked, false if failed (default true)
+   * @param {string} [options.context] - What went wrong (triggers evolution on failure)
+   * @param {number} [options.failedAtStep] - Which step number failed
    * @returns {Promise<object>}
    */
   async procedureFeedback(procedureId, options = {}) {
     const success = options.success !== false;
-    return this._request('PATCH', `/v1/procedures/${procedureId}/feedback`, null, {
+    const body = options.context ? {
+      context: options.context,
+      ...(options.failedAtStep != null && { failed_at_step: options.failedAtStep }),
+    } : null;
+    return this._request('PATCH', `/v1/procedures/${procedureId}/feedback`, body, {
       success: success ? 'true' : 'false',
     });
   }
 
+  /**
+   * Get version history for a procedure.
+   * @param {string} procedureId - UUID of any version of the procedure
+   * @returns {Promise<{versions: Array, evolution_log: Array}>}
+   */
+  async procedureHistory(procedureId) {
+    return this._request('GET', `/v1/procedures/${procedureId}/history`);
+  }
+
+  /**
+   * Get the evolution log for a procedure.
+   * @param {string} procedureId - UUID of any version of the procedure
+   * @returns {Promise<{evolution: Array}>}
+   */
+  async procedureEvolution(procedureId) {
+    return this._request('GET', `/v1/procedures/${procedureId}/evolution`);
+  }
+
   // ---- Unified Search ----
 
   /**
@@ -521,12 +546,13 @@ class MengramClient {
    * @param {number} [options.limit] - max triggers to return
    * @returns {Promise<Array>}
    */
-  async getTriggers(userId = 'default', options = {}) {
+  async getTriggers(userId = null, options = {}) {
     const params = new URLSearchParams();
     if (options.includeFired) params.set('include_fired', 'true');
     if (options.limit) params.set('limit', options.limit);
     const qs = params.toString() ? `?${params}` : '';
-    const result = await this._request('GET', `/v1/triggers/${userId}${qs}`);
+    const path = userId ? `/v1/triggers/${userId}${qs}` : `/v1/triggers${qs}`;
+    const result = await this._request('GET', path);
     return result.triggers || [];
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mengram-ai",
-  "version": "2.6.1",
-  "description": "Human-like memory for AI — semantic, episodic & procedural memory. Cognitive Profile, unified search, memory agents. Free Mem0 alternative.",
+  "version": "2.7.0",
+  "description": "Human-like memory for AI — semantic, episodic & procedural memory. Experience-driven procedures, Cognitive Profile, unified search, memory agents. Free Mem0 alternative.",
   "main": "index.js",
   "types": "index.d.ts",
   "license": "Apache-2.0",