@lanonasis/mem-intel-sdk 2.0.2 → 2.0.5

package/dist/server/index.cjs

@@ -617,6 +617,176 @@ var MemoryIntelligenceClient = class {
   async recordPredictionFeedback(params) {
     await this.httpClient.post("/intelligence/prediction-feedback", params);
   }
+  // ============================================================================
+  // Behavioral Learning Methods
+  // ============================================================================
+  /**
+   * Record a successful behavior pattern for future recall
+   *
+   * The system automatically:
+   * - Generates an embedding from the trigger description
+   * - Detects and updates duplicates (>95% similarity)
+   * - Tracks usage counts for pattern prioritization
+   *
+   * @example
+   * ```typescript
+   * const result = await client.recordBehavior({
+   *   user_id: "user-123",
+   *   trigger: "User wants to refactor a React component to use hooks",
+   *   context: {
+   *     project: "dashboard-app",
+   *     active_files: ["src/components/DataTable.tsx"]
+   *   },
+   *   actions: [
+   *     { tool: "read_file", params: { path: "src/components/DataTable.tsx" } },
+   *     { tool: "analyze_code", params: { focus: "class_components" } },
+   *     { tool: "edit_file", params: { path: "src/components/DataTable.tsx" } }
+   *   ],
+   *   final_outcome: "Successfully converted class component to functional with hooks"
+   * });
+   *
+   * if (result.data.was_duplicate) {
+   *   console.log("Updated existing pattern:", result.data.pattern.id);
+   * }
+   * ```
+   */
+  async recordBehavior(params) {
+    const response = await this.httpClient.postEnhanced(
+      "/intelligence/behavior-record",
+      {
+        user_id: params.user_id,
+        trigger: params.trigger,
+        context: params.context || {},
+        actions: params.actions,
+        final_outcome: params.final_outcome,
+        confidence: params.confidence ?? 0.7
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to record behavior: ${response.error.message}`);
+    }
+    const data = response.data;
+    return {
+      data: {
+        pattern: data.data || data,
+        was_duplicate: data.message?.includes("duplicate") || false,
+        message: data.message || "Behavior pattern recorded successfully"
+      },
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
+  }
+  /**
+   * Recall similar behavior patterns based on current context
+   *
+   * Use this to find workflows that match the user's current task,
+   * enabling AI assistants to suggest proven approaches.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.recallBehavior({
+   *   user_id: "user-123",
+   *   context: {
+   *     current_task: "Need to optimize database queries for user dashboard"
+   *   },
+   *   limit: 5,
+   *   similarity_threshold: 0.7
+   * });
+   *
+   * for (const match of result.data.patterns) {
+   *   console.log(`[${Math.round(match.similarity_score * 100)}%] ${match.pattern.trigger}`);
+   *   console.log(`  Actions: ${match.pattern.actions.map(a => a.tool).join(" → ")}`);
+   * }
+   * ```
+   */
+  async recallBehavior(params) {
+    const response = await this.httpClient.postEnhanced(
+      "/intelligence/behavior-recall",
+      {
+        user_id: params.user_id,
+        context: params.context,
+        limit: params.limit ?? 5,
+        similarity_threshold: params.similarity_threshold ?? 0.7
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to recall behaviors: ${response.error.message}`);
+    }
+    const data = response.data;
+    return {
+      data: data.data || data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
+  }
+  /**
+   * Get AI-powered action suggestions based on learned patterns
+   *
+   * Analyzes the current state and completed steps to predict
+   * what action the user should take next based on similar workflows.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.suggestAction({
+   *   user_id: "user-123",
+   *   current_state: {
+   *     task_description: "Implementing user authentication with OAuth",
+   *     completed_steps: [
+   *       { tool: "create_file", params: { path: "src/auth/oauth.ts" } },
+   *       { tool: "read_file", params: { path: "package.json" } }
+   *     ]
+   *   },
+   *   max_suggestions: 3
+   * });
+   *
+   * for (const suggestion of result.data.suggestions) {
+   *   console.log(`[${Math.round(suggestion.confidence * 100)}%] ${suggestion.action}`);
+   *   console.log(`  Tool: ${suggestion.tool}`);
+   *   console.log(`  Why: ${suggestion.reasoning}`);
+   * }
+   * ```
+   */
+  async suggestAction(params) {
+    const response = await this.httpClient.postEnhanced(
+      "/intelligence/behavior-suggest",
+      {
+        user_id: params.user_id,
+        current_state: params.current_state,
+        max_suggestions: params.max_suggestions ?? 3
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to get action suggestions: ${response.error.message}`);
+    }
+    const data = response.data;
+    return {
+      data: data.data || data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
+  }
+  /**
+   * List all behavior patterns for a user
+   *
+   * @example
+   * ```typescript
+   * const patterns = await client.listBehaviorPatterns("user-123", { limit: 20 });
+   * console.log(`Found ${patterns.length} patterns`);
+   * ```
+   */
+  async listBehaviorPatterns(userId, options = {}) {
+    const { limit = 50, offset = 0 } = options;
+    const response = await this.httpClient.get(
+      `/intelligence/behavior-patterns?user_id=${userId}&limit=${limit}&offset=${offset}`
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to list behavior patterns: ${response.error.message}`);
+    }
+    return response.data?.patterns || [];
+  }
 };
 var ResponseFormat = {
   JSON: "json",
@@ -1334,6 +1504,188 @@ ${data.overall_summary}
       }
     }
   );
+  server.registerTool(
+    "behavior_record",
+    {
+      title: "Record Behavior Pattern",
+      description: `Record a successful workflow pattern for future recall.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        trigger: zod.z.string().min(1, "Trigger description is required"),
+        context: zod.z.object({
+          directory: zod.z.string(),
+          project_type: zod.z.string().optional(),
+          branch: zod.z.string().optional(),
+          files_touched: zod.z.array(zod.z.string()).optional()
+        }).optional(),
+        actions: zod.z.array(zod.z.object({
+          tool: zod.z.string(),
+          parameters: zod.z.record(zod.z.unknown()).optional(),
+          outcome: zod.z.enum(["success", "partial", "failed"]),
+          timestamp: zod.z.string().optional(),
+          duration_ms: zod.z.number().optional()
+        })).min(1, "At least one action is required"),
+        final_outcome: zod.z.enum(["success", "partial", "failed"]),
+        confidence: zod.z.number().min(0).max(1).default(0.7)
+      }).strict(),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.recordBehavior({
+          user_id: rawParams.user_id,
+          trigger: rawParams.trigger,
+          context: rawParams.context || {},
+          actions: rawParams.actions,
+          final_outcome: rawParams.final_outcome,
+          confidence: rawParams.confidence
+        });
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior pattern recorded: ${response.data.message}
+Pattern ID: ${response.data.pattern.id}
+Was duplicate: ${response.data.was_duplicate}`
+          }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "behavior_recall",
+    {
+      title: "Recall Behavior Patterns",
+      description: `Recall similar behavior patterns based on current context.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        context: zod.z.object({
+          current_task: zod.z.string().min(1, "Current task description is required"),
+          directory: zod.z.string().optional(),
+          project_type: zod.z.string().optional()
+        }),
+        limit: zod.z.number().int().min(1).max(20).default(5),
+        similarity_threshold: zod.z.number().min(0).max(1).default(0.7)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.recallBehavior({
+          user_id: rawParams.user_id,
+          context: rawParams.context,
+          limit: rawParams.limit,
+          similarity_threshold: rawParams.similarity_threshold
+        });
+        const patterns = response.data?.patterns || [];
+        let text = `Found ${patterns.length} behavior patterns:
+
+`;
+        patterns.forEach((pattern, i) => {
+          text += `${i + 1}. "${pattern.pattern.trigger}" (${Math.round(pattern.similarity_score * 100)}% similar)
+`;
+          text += `   Actions: ${pattern.pattern.actions.map((a) => a.tool).join(" \u2192 ")}
+`;
+          text += `   Outcome: ${pattern.pattern.final_outcome}
+
+`;
+        });
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "behavior_suggest",
+    {
+      title: "Suggest Next Actions",
+      description: `Get AI-powered action suggestions based on learned patterns.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        current_state: zod.z.object({
+          task_description: zod.z.string().min(1, "Task description is required"),
+          completed_steps: zod.z.array(zod.z.object({
+            tool: zod.z.string(),
+            params: zod.z.record(zod.z.unknown()).optional()
+          })).optional()
+        }),
+        max_suggestions: zod.z.number().int().min(1).max(10).default(3)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.suggestAction({
+          user_id: rawParams.user_id,
+          current_state: rawParams.current_state,
+          max_suggestions: rawParams.max_suggestions
+        });
+        const suggestions = response.data?.suggestions || [];
+        let text = `Suggested actions:
+
+`;
+        suggestions.forEach((suggestion, i) => {
+          text += `${i + 1}. ${suggestion.action}
+`;
+          text += `   Tool: ${suggestion.tool}
+`;
+          text += `   Confidence: ${Math.round(suggestion.confidence * 100)}%
+`;
+          text += `   Reasoning: ${suggestion.reasoning}
+
+`;
+        });
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
   return server;
 }