@lanonasis/mem-intel-sdk 1.1.0 → 2.0.1

package/dist/server/index.cjs

@@ -160,23 +160,48 @@ var HttpClient = class {
   processingMode;
   cache;
   constructor(config) {
-    if (!config.apiKey) {
-      throw new ConfigurationError("API key is required");
-    }
-    if (!config.apiKey.startsWith("lano_")) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    let authType;
+    if (config.authType) {
+      authType = config.authType;
+    } else if (config.apiKey) {
+      authType = "apiKey";
+    } else if (config.authToken) {
+      authType = "bearer";
+    } else if (config.allowMissingAuth) {
+      authType = "apiKey";
+    } else {
       throw new ConfigurationError(
-        "Invalid API key format. API key should start with 'lano_'"
+        "Authentication required: provide apiKey, authToken, or set allowMissingAuth to true"
       );
     }
-    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    const allowMissingAuth = Boolean(config.allowMissingAuth);
+    if (authType === "apiKey") {
+      if (!config.apiKey && !allowMissingAuth) {
+        throw new ConfigurationError("API key is required when authType is 'apiKey'");
+      }
+      if (config.apiKey && !config.apiKey.startsWith("lano_")) {
+        throw new ConfigurationError(
+          "Invalid API key format. API key should start with 'lano_'"
+        );
+      }
+    } else if (!config.authToken && !allowMissingAuth) {
+      throw new ConfigurationError("Bearer token is required when authType is 'bearer'");
+    }
     this.apiKey = config.apiKey;
     this.timeout = config.timeout || 3e4;
     this.processingMode = config.processingMode || "api";
-    this.headers = {
+    const baseHeaders = {
       "Content-Type": "application/json",
-      "X-API-Key": this.apiKey,
       ...config.headers
     };
+    if (authType === "apiKey" && this.apiKey && !("X-API-Key" in baseHeaders)) {
+      baseHeaders["X-API-Key"] = this.apiKey;
+    }
+    if (authType === "bearer" && config.authToken && !("Authorization" in baseHeaders)) {
+      baseHeaders["Authorization"] = `Bearer ${config.authToken}`;
+    }
+    this.headers = baseHeaders;
     if (config.enableCache !== false && this.processingMode === "offline-fallback") {
       this.cache = new ResponseCache(config.cacheTTL || 3e5);
     } else {
@@ -336,15 +361,14 @@ var MemoryIntelligenceClient = class {
   defaultResponseFormat;
   processingMode;
   constructor(config) {
-    if (!config.apiKey) {
-      throw new ConfigurationError(
-        "Missing required configuration: apiKey is required (format: lano_xxxxxxxxxx)"
-      );
-    }
     this.processingMode = config.processingMode || "api";
+    const authType = config.authType || (config.apiKey ? "apiKey" : "bearer");
     this.httpClient = new HttpClient({
       apiUrl: config.apiUrl || DEFAULT_API_URL,
       apiKey: config.apiKey,
+      authToken: config.authToken,
+      authType,
+      allowMissingAuth: config.allowMissingAuth,
       timeout: config.timeout,
       headers: config.headers,
       processingMode: this.processingMode,
@@ -524,6 +548,75 @@ var MemoryIntelligenceClient = class {
       fromCache: response.fromCache
     };
   }
+  /**
+   * Predictive Memory Recall - AI that anticipates what you need
+   *
+   * Uses a weighted scoring algorithm:
+   *   - Semantic similarity to current context (40%)
+   *   - Temporal relevance (recency decay curve) (30%)
+   *   - Usage frequency (20%)
+   *   - Serendipity factor (adjacent discoveries) (10%)
+   *
+   * @example
+   * ```typescript
+   * const result = await client.predictiveRecall({
+   *   userId: "user-123",
+   *   context: {
+   *     currentProject: "Building dashboard components",
+   *     recentTopics: ["React", "performance", "hooks"],
+   *     contextText: "Optimizing render performance for data tables"
+   *   },
+   *   limit: 5,
+   *   minConfidence: 50
+   * });
+   *
+   * for (const prediction of result.data.predictions) {
+   *   console.log(`[${prediction.confidence}%] ${prediction.title}`);
+   *   console.log(`  Reason: ${prediction.reason}`);
+   *   console.log(`  Action: ${prediction.suggestedAction}`);
+   * }
+   * ```
+   */
+  async predictiveRecall(params) {
+    const response = await this.httpClient.postEnhanced(
+      "/intelligence/predictive-recall",
+      {
+        userId: params.userId,
+        context: params.context,
+        limit: params.limit || 5,
+        minConfidence: params.minConfidence || 40,
+        includeSerendipity: params.includeSerendipity !== false,
+        memoryTypes: params.memoryTypes,
+        timeWindowDays: params.timeWindowDays || 90,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to get predictions: ${response.error.message}`);
+    }
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
+  }
+  /**
+   * Record feedback on a prediction (for improving accuracy over time)
+   *
+   * @example
+   * ```typescript
+   * await client.recordPredictionFeedback({
+   *   memoryId: "mem-123",
+   *   userId: "user-123",
+   *   useful: true,
+   *   action: "clicked"
+   * });
+   * ```
+   */
+  async recordPredictionFeedback(params) {
+    await this.httpClient.post("/intelligence/prediction-feedback", params);
+  }
 };
 var ResponseFormat = {
   JSON: "json",
@@ -828,22 +921,27 @@ function createMCPServer(config) {
             let md = `# Duplicate Detection
 
 `;
-            md += `**Memories Analyzed:** ${data.total_memories_analyzed}
+            md += `**Memories Analyzed:** ${data.memories_analyzed}
+`;
+            md += `**Duplicate Groups Found:** ${data.total_groups}
 `;
-            md += `**Duplicate Pairs Found:** ${data.duplicate_pairs_found}
+            md += `**Total Duplicates:** ${data.total_duplicates}
 `;
-            md += `**Storage Savings:** ${data.estimated_storage_savings}
+            md += `**Storage Savings:** ${data.potential_storage_savings}
 
 `;
-            for (const pair of data.duplicate_pairs) {
-              md += `### Similarity: ${(pair.similarity_score * 100).toFixed(1)}%
+            for (const group of data.duplicate_groups) {
+              md += `### ${group.primary_title}
 `;
-              md += `**Memory 1:** ${pair.memory_1.title}
+              md += `**Similarity Score:** ${(group.similarity_score * 100).toFixed(1)}%
 `;
-              md += `**Memory 2:** ${pair.memory_2.title}
+              md += `**Duplicates:**
 `;
-              md += `**Recommendation:** ${pair.recommendation}
-
+              for (const dup of group.duplicates) {
+                md += `- ${dup.title} (${(dup.similarity * 100).toFixed(1)}% similar)
+`;
+              }
+              md += `
 `;
             }
             return md;
@@ -902,7 +1000,7 @@ function createMCPServer(config) {
             let md = `# Memory Insights
 
 `;
-            md += `**Memories Analyzed:** ${data.total_memories_analyzed}
+            md += `**Memories Analyzed:** ${data.memories_analyzed}
 `;
             if (data.topic_filter) {
               md += `**Topic:** ${data.topic_filter}
@@ -910,24 +1008,24 @@ function createMCPServer(config) {
             }
             md += `
 ## Summary
-${data.summary}
+${data.overall_summary}
 
 `;
             md += `## Insights
 `;
-            const categoryIcons = {
-              pattern: "\u{1F504}",
-              learning: "\u{1F4A1}",
-              opportunity: "\u{1F680}",
-              risk: "\u26A0\uFE0F",
-              action_item: "\u2705"
+            const typeIcons = {
+              themes: "\u{1F3AF}",
+              connections: "\u{1F517}",
+              gaps: "\u26A0\uFE0F",
+              actions: "\u2705",
+              summary: "\u{1F4CB}"
             };
             for (const insight of data.insights) {
-              const icon = categoryIcons[insight.category] || "\u{1F4CC}";
+              const icon = typeIcons[insight.type] || "\u{1F4CC}";
               md += `
-### ${icon} ${insight.title}
+### ${icon} ${insight.type.charAt(0).toUpperCase() + insight.type.slice(1)}
 `;
-              md += `${insight.description}
+              md += `${insight.content}
 `;
               md += `**Confidence:** ${(insight.confidence * 100).toFixed(0)}%
 `;
@@ -982,25 +1080,43 @@ ${data.summary}
             let md = `# Memory Health Check
 
 `;
-            md += `**Health Score:** ${data.health_score}/100
+            md += `**Health Score:** ${data.health_score.overall}/100
+`;
+            md += `**Status:** ${data.status}
+
+`;
+            md += `## Score Breakdown
+`;
+            md += `- **Organization:** ${data.health_score.breakdown.organization}
+`;
+            md += `- **Tagging:** ${data.health_score.breakdown.tagging}
+`;
+            md += `- **Recency:** ${data.health_score.breakdown.recency}
+`;
+            md += `- **Completeness:** ${data.health_score.breakdown.completeness}
+`;
+            md += `- **Diversity:** ${data.health_score.breakdown.diversity}
 
 `;
-            md += `## Metrics
+            md += `## Statistics
+`;
+            md += `- **Total Memories:** ${data.statistics.total_memories}
 `;
-            md += `- **Total Memories:** ${data.metrics.total_memories}
+            md += `- **Active Memories:** ${data.statistics.active_memories}
 `;
-            md += `- **Embedding Coverage:** ${data.metrics.embedding_coverage_percentage}%
+            md += `- **Memories with Tags:** ${data.statistics.memories_with_tags}
 `;
-            md += `- **Tagging Rate:** ${data.metrics.tagging_percentage}%
+            md += `- **Unique Tags:** ${data.statistics.unique_tags}
 `;
-            md += `- **Avg Tags/Memory:** ${data.metrics.average_tags_per_memory}
+            md += `- **Recent (30d):** ${data.statistics.recent_memories_30d}
 
 `;
             if (data.issues.length > 0) {
               md += `## Issues
 `;
               for (const issue of data.issues) {
-                md += `- ${issue}
+                const icon = issue.severity === "high" ? "\u{1F534}" : issue.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+                md += `- ${icon} **${issue.category}:** ${issue.description}
 `;
               }
               md += `
@@ -1031,6 +1147,193 @@ ${data.summary}
       }
     }
   );
+  server.registerTool(
+    "memory_predictive_recall",
+    {
+      title: "Predictive Memory Recall",
+      description: `AI-powered prediction of memories you'll need based on your current context. Uses semantic similarity, temporal relevance, usage patterns, and serendipity scoring to anticipate what you need before you realize it.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        context: zod.z.object({
+          current_project: zod.z.string().optional().describe("Current project or task description"),
+          recent_topics: zod.z.array(zod.z.string()).optional().describe("Recent topics you've been working on"),
+          active_files: zod.z.array(zod.z.string()).optional().describe("Files currently being worked on"),
+          context_text: zod.z.string().optional().describe("Free-form context (current task, meeting notes, etc.)"),
+          team_context: zod.z.string().optional().describe("Team discussion topics for team-aware predictions")
+        }).describe("Your current work context for generating predictions"),
+        limit: zod.z.number().int().min(1).max(20).default(5).describe("Maximum predictions to return"),
+        min_confidence: zod.z.number().min(0).max(100).default(40).describe("Minimum confidence threshold (0-100)"),
+        include_serendipity: zod.z.boolean().default(true).describe("Include surprising adjacent discoveries"),
+        memory_types: zod.z.array(MemoryType).optional().describe("Filter by memory types"),
+        time_window_days: zod.z.number().int().min(1).max(365).default(90).describe("Time window for recency scoring"),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          userId: rawParams.user_id,
+          context: {
+            currentProject: rawParams.context?.current_project,
+            recentTopics: rawParams.context?.recent_topics,
+            activeFiles: rawParams.context?.active_files,
+            contextText: rawParams.context?.context_text,
+            teamContext: rawParams.context?.team_context
+          },
+          limit: rawParams.limit,
+          minConfidence: rawParams.min_confidence,
+          includeSerendipity: rawParams.include_serendipity,
+          memoryTypes: rawParams.memory_types,
+          timeWindowDays: rawParams.time_window_days,
+          responseFormat: rawParams.response_format
+        };
+        const response = await client.predictiveRecall(params);
+        const result = response.data;
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Predicted Memories for You
+
+`;
+            md += `**Memories Analyzed:** ${data.memoriesAnalyzed}
+`;
+            md += `**Predictions Found:** ${data.totalPredictions}
+
+`;
+            if (data.predictions.length === 0) {
+              md += `_No predictions above the confidence threshold. Try providing more context or lowering the threshold._
+`;
+              return md;
+            }
+            md += `## Your Predictions
+
+`;
+            for (const pred of data.predictions) {
+              const confidenceIcon = pred.confidence >= 80 ? "\u{1F3AF}" : pred.confidence >= 60 ? "\u2728" : pred.confidence >= 40 ? "\u{1F4A1}" : "\u{1F50D}";
+              const actionIcon = pred.suggestedAction === "apply" ? "\u26A1" : pred.suggestedAction === "reference" ? "\u{1F4DA}" : pred.suggestedAction === "explore" ? "\u{1F52D}" : "\u{1F440}";
+              md += `### ${confidenceIcon} ${pred.title}
+`;
+              md += `**Confidence:** ${pred.confidence}% | **Type:** ${pred.type}
+`;
+              md += `**Why:** ${pred.reason}
+`;
+              md += `**Suggested Action:** ${actionIcon} ${pred.suggestedAction}
+`;
+              if (pred.tags.length > 0) {
+                md += `**Tags:** ${pred.tags.slice(0, 5).join(", ")}
+`;
+              }
+              md += `
+> ${pred.contentPreview}
+
+`;
+              md += `<details>
+<summary>Score Breakdown</summary>
+
+`;
+              md += `- Semantic: ${pred.scoreBreakdown.semanticScore}%
+`;
+              md += `- Temporal: ${pred.scoreBreakdown.temporalScore}%
+`;
+              md += `- Frequency: ${pred.scoreBreakdown.frequencyScore}%
+`;
+              md += `- Serendipity: ${pred.scoreBreakdown.serendipityScore}%
+`;
+              md += `- **Combined:** ${pred.scoreBreakdown.combinedScore}%
+`;
+              md += `</details>
+
+`;
+              md += `---
+
+`;
+            }
+            md += `## Algorithm Info
+`;
+            md += `- **Version:** ${data.algorithmInfo.version}
+`;
+            md += `- **Embedding Model:** ${data.algorithmInfo.embeddingModel}
+`;
+            md += `- **Time Window:** ${data.algorithmInfo.timeWindowDays} days
+`;
+            md += `- **Weights:** Semantic ${data.scoringWeights.semantic * 100}%, `;
+            md += `Temporal ${data.scoringWeights.temporal * 100}%, `;
+            md += `Frequency ${data.scoringWeights.frequency * 100}%, `;
+            md += `Serendipity ${data.scoringWeights.serendipity * 100}%
+`;
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_prediction_feedback",
+    {
+      title: "Record Prediction Feedback",
+      description: `Record whether a prediction was useful. This helps improve future predictions.`,
+      inputSchema: zod.z.object({
+        memory_id: zod.z.string().uuid(),
+        user_id: zod.z.string().uuid(),
+        useful: zod.z.boolean().describe("Was this prediction useful?"),
+        action: zod.z.enum(["clicked", "saved", "dismissed", "ignored"]).describe("What action was taken"),
+        dismiss_reason: zod.z.enum(["not_relevant", "already_know", "not_now", "other"]).optional().describe("Reason for dismissal")
+      }).strict(),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (rawParams) => {
+      try {
+        await client.recordPredictionFeedback({
+          memoryId: rawParams.memory_id,
+          userId: rawParams.user_id,
+          useful: rawParams.useful,
+          action: rawParams.action,
+          dismissReason: rawParams.dismiss_reason
+        });
+        return {
+          content: [{
+            type: "text",
+            text: `Feedback recorded. Thank you for helping improve predictions!`
+          }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
   return server;
 }