@cachly-dev/mcp-server 0.10.14 → 0.10.15

package/src/handlers/team.ts

@@ -5,6 +5,7 @@ import type { Redis } from 'ioredis';
 import { calculateConfidence, confidenceBadge, CONFIDENCE_STALE_VALUE, CONFIDENCE_WARN_VALUE,
          CONFIDENCE_WARN_DAYS, CONFIDENCE_STALE_DAYS, simpleHash } from '../confidence.js';
 import type { Instance } from './brain.js';
+import { safeJsonParse } from '../utils.js';
 
 type GetConnection = (instanceId: string) => Promise<Redis>;
 type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
@@ -53,10 +54,11 @@ export async function handleTeamTool(
 
       type Lesson = { topic: string; what_worked: string; outcome: string; file_paths?: string[] };
       const relevant: string[] = [];
-      for (const k of lessonKeys) {
-        const raw = await redis.get(k);
+      const sfRaws = lessonKeys.length > 0 ? await redis.mget(...lessonKeys) : [];
+      for (const raw of sfRaws) {
         if (!raw) continue;
-        const lesson = JSON.parse(raw) as Lesson;
+        const lesson = safeJsonParse<Lesson | null>(raw, null);
+        if (!lesson) continue;
         // Match by file_paths stored in lesson OR by topic keywords matching file name
         const topicWords = lesson.topic.toLowerCase().split(/[:\-_]/);
         const fileMatches = changed_files.some(f => {
@@ -146,10 +148,12 @@ export async function handleTeamTool(
         author?: string; tags?: string[];
       };
       let lessons: TeamLesson[] = [];
-      for (const k of lessonKeys) {
-        const raw = await redis.get(k);
-        if (!raw) continue;
-        try { lessons.push(JSON.parse(raw) as TeamLesson); } catch { /* skip */ }
+      if (lessonKeys.length > 0) {
+        const raws = await redis.mget(...lessonKeys);
+        for (const raw of raws) {
+          const l = safeJsonParse<TeamLesson | null>(raw ?? null, null);
+          if (l) lessons.push(l);
+        }
       }
 
       // Filter
@@ -278,10 +282,12 @@ export async function handleTeamTool(
 
       type RawLesson = { topic: string; outcome: string; what_worked: string; severity?: string; ts: string; auto_learned?: boolean };
       const allLessons: RawLesson[] = [];
-      for (const k of allLessonKeys) {
-        const raw = await redis.get(k);
-        if (!raw) continue;
-        try { allLessons.push(JSON.parse(raw) as RawLesson); } catch { /* skip */ }
+      if (allLessonKeys.length > 0) {
+        const raws = await redis.mget(...allLessonKeys);
+        for (const raw of raws) {
+          const l = safeJsonParse<RawLesson | null>(raw ?? null, null);
+          if (l) allLessons.push(l);
+        }
       }
 
       // Group lessons by top-level category
@@ -367,18 +373,17 @@ export async function handleTeamTool(
         verified_at?: string; severity?: string; audit_trail?: unknown[];
       };
       const lessons: DrLesson[] = [];
-      for (const k of lessonKeys) {
-        const raw = await redis.get(k);
-        if (!raw) continue;
-        try { lessons.push(JSON.parse(raw) as DrLesson); } catch { /* skip */ }
+      if (lessonKeys.length > 0) {
+        const raws = await redis.mget(...lessonKeys);
+        for (const raw of raws) {
+          const l = safeJsonParse<DrLesson | null>(raw ?? null, null);
+          if (l) lessons.push(l);
+        }
       }
 
       // Last session
       const lastSessionRaw = await redis.get('cachly:session:last');
-      let lastSession: { ts: string; summary: string } | null = null;
-      if (lastSessionRaw) {
-        try { lastSession = JSON.parse(lastSessionRaw); } catch { /* ignore */ }
-      }
+      const lastSession = safeJsonParse<{ ts: string; summary: string } | null>(lastSessionRaw, null);
 
       // Open failures
       const openFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial');
@@ -509,13 +514,24 @@ export async function handleTeamTool(
         issues.push(`💡 ${unusedLessons.length} lessons never recalled — verify topics match your workflow`);
       }
 
-      const lines = ['🩺 **Brain Doctor Report**', '', ...checks.map(c => '  ' + c), ''];
+      const divider = '─'.repeat(48);
+      const lines = [
+        `🩺 **Brain Doctor**`,
+        `\`${divider}\``,
+        '',
+        '**📊 Health Checks**',
+        ...checks.map(c => '  ' + c),
+        '',
+      ];
       if (issues.length > 0) {
-        lines.push('**Issues to fix:**');
-        for (const i of issues) lines.push('  ' + i);
+        lines.push(`**🔧 Action Items** (${issues.length} issue${issues.length > 1 ? 's' : ''})`);
+        issues.forEach((item, idx) => lines.push(`  ${idx + 1}. ${item}`));
         lines.push('');
+        lines.push(`_Fix the action items above, then re-run \`brain_doctor\` to verify._`);
       } else {
-        lines.push('  🎉 Brain looks healthy! Keep calling session_start/session_end.');
+        lines.push('**✅ All checks passed** — Brain is healthy!');
+        lines.push('');
+        lines.push('_Keep the brain sharp: `session_start` → work → `learn_from_attempts` → `session_end`_');
       }
       return lines.join('\n');
     }
@@ -536,7 +552,11 @@ export async function handleTeamTool(
         .filter((l): l is NonNullable<typeof l> => l !== null && new Date(l.ts).getTime() <= cutoff)
         .sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
 
-      if (before.length === 0) return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${new Date(JSON.parse(all[0]).ts).toLocaleDateString('de-DE')}.`;
+      if (before.length === 0) {
+        const first = safeJsonParse(all[0] ?? null, null as null | { ts?: string });
+        const earliest = first?.ts ? new Date(first.ts).toLocaleDateString('de-DE') : 'unknown';
+        return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${earliest}.`;
+      }
 
       const lines = [
         `🏺 **Brain Archaeology: \`${topic}\` before ${date}**`,
@@ -563,7 +583,7 @@ export async function handleTeamTool(
       const raw = await redis.get(depKey);
       if (!raw) return `📭 No lessons found that depend on \`${dependency}\`.\n\nAdd dependencies via: \`learn_from_attempts(..., depends_on=["${dependency}"])\``;
 
-      const topics: string[] = JSON.parse(raw);
+      const topics: string[] = safeJsonParse<string[]>(raw, []);
       const lines = [
         `🔗 **Causal Chain: \`${dependency}\`** — ${topics.length} dependent lesson${topics.length === 1 ? '' : 's'}`,
         '',
@@ -572,7 +592,8 @@ export async function handleTeamTool(
       for (const t of topics) {
         const lessonRaw = await redis.get(`cachly:lesson:best:${t}`);
         if (!lessonRaw) { lines.push(`  • \`${t}\` _(lesson deleted)_`); continue; }
-        const lesson = JSON.parse(lessonRaw) as { outcome?: string; severity?: string; needs_review?: boolean };
+        const lesson = safeJsonParse(lessonRaw, null as null | { outcome?: string; severity?: string; needs_review?: boolean });
+        if (!lesson) { lines.push(`  • \`${t}\` _(lesson corrupted)_`); continue; }
         const emoji = lesson.outcome === 'success' ? '✅' : lesson.outcome === 'partial' ? '⚠️' : '❌';
         const reviewBadge = lesson.needs_review ? ' 🔍 **needs_review**' : '';
         lines.push(`  ${emoji} \`${t}\` (${lesson.severity ?? 'major'})${reviewBadge}`);
@@ -614,8 +635,8 @@ export async function handleTeamTool(
       // Preserve recall_count on update
       const existing = await redis.get(key);
       if (existing) {
-        const prev = JSON.parse(existing) as { recall_count?: number };
-        record.recall_count = prev.recall_count ?? 0;
+        const prev = safeJsonParse(existing, null as null | { recall_count?: number });
+        record.recall_count = prev?.recall_count ?? 0;
       }
       await redis.set(key, JSON.stringify(record));
       return `🌐 **Global lesson stored**: \`${topic}\`\n\n${lesson}\n\nRecallable from any project via \`global_recall(topic="${topic}")\`.`;
@@ -635,10 +656,12 @@ export async function handleTeamTool(
 
       type GlobalLesson = { topic: string; lesson: string; severity?: string; ts: string; recall_count?: number };
       let lessons: GlobalLesson[] = [];
-      for (const k of keys) {
-        const raw = await redis.get(k);
-        if (!raw) continue;
-        try { lessons.push(JSON.parse(raw) as GlobalLesson); } catch { /* skip */ }
+      if (keys.length > 0) {
+        const raws = await redis.mget(...keys);
+        for (const raw of raws) {
+          const l = safeJsonParse<GlobalLesson | null>(raw ?? null, null);
+          if (l) lessons.push(l);
+        }
       }
 
       if (topic) {
@@ -655,7 +678,8 @@ export async function handleTeamTool(
         const k = `cachly:global:lesson:${l.topic}`;
         const raw = await redis.get(k);
         if (raw) {
-          const rec = JSON.parse(raw) as { recall_count?: number };
+          const rec = safeJsonParse(raw, null as null | { recall_count?: number });
+          if (!rec) continue;
           rec.recall_count = (rec.recall_count ?? 0) + 1;
           await redis.set(k, JSON.stringify(rec));
         }