@cachly-dev/mcp-server 0.10.42 → 0.10.44

package/src/__tests__/brain-flow.test.ts

@@ -17,6 +17,7 @@ import { EventEmitter } from 'node:events';
 import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge } from '../ckg.js';
 import { EMBED_PROVIDER, hasEmbedProvider, embedProviderHint, embedConfig, setEmbedJwt } from '../embeddings.js';
 import { keywordSearch } from '../search.js';
+import { handleBrainTool } from '../handlers/brain.js';
 import type { Redis } from 'ioredis';
 
 // ── In-memory Redis mock ──────────────────────────────────────────────────────
@@ -67,6 +68,21 @@ class MockRedis {
     return [...(this.sets.get(key) ?? [])];
   }
 
+  async mget(...keys: string[]): Promise<(string | null)[]> {
+    return keys.map(k => this.store.get(k) ?? null);
+  }
+
+  async exists(key: string): Promise<number> {
+    return this.store.has(key) ? 1 : 0;
+  }
+
+  async incrbyfloat(key: string, increment: number): Promise<string> {
+    const cur = parseFloat(this.store.get(key) ?? '0');
+    const next = cur + increment;
+    this.store.set(key, String(next));
+    return String(next);
+  }
+
   /** Simplified scanStream: returns all matching keys in a single 'data' event. */
   scanStream(opts: { match: string; count?: number }): EventEmitter {
     const emitter = new EventEmitter();
@@ -872,3 +888,161 @@ describe('Brain Flow: advanced scenarios', () => {
     });
   });
 });
+
+// ── New feature coverage (0.10.41 / 0.10.42) ─────────────────────────────────
+// Trust badges, Proven Laws crystallization, and focus-less predictive warning.
+// These exercise the REAL handleBrainTool code path with the MockRedis.
+
+const noopApiFetch = (async () => null) as unknown as Parameters<typeof handleBrainTool>[3];
+
+/** Seed a best-solution lesson with an explicit recall_count / authors / pinned. */
+async function seedLesson(
+  redis: MockRedis,
+  topic: string,
+  opts: {
+    outcome?: 'success' | 'failure' | 'partial';
+    what_worked?: string;
+    what_failed?: string;
+    recall_count?: number;
+    severity?: 'critical' | 'major' | 'minor';
+    pinned?: boolean;
+    author?: string;
+    tags?: string[];
+  } = {},
+): Promise<void> {
+  const ts = new Date().toISOString();
+  const obj = {
+    topic,
+    outcome: opts.outcome ?? 'success',
+    what_worked: opts.what_worked ?? `solution for ${topic}`,
+    what_failed: opts.what_failed,
+    severity: opts.severity ?? 'minor',
+    recall_count: opts.recall_count ?? 0,
+    ts,
+    verified_at: ts,
+    confidence: 1.0,
+    tags: opts.tags ?? [],
+    ...(opts.pinned ? { pinned: true } : {}),
+    ...(opts.author ? { author: opts.author } : {}),
+  };
+  await redis.set(`cachly:lesson:best:${topic}`, JSON.stringify(obj));
+}
+
+describe('Trust badges (recall_best_solution)', () => {
+  let redis: MockRedis;
+  const getConn = async () => redis as unknown as Redis;
+  beforeEach(() => { redis = new MockRedis(); });
+
+  it('shows "Battle-tested" when recall_count crosses 10', async () => {
+    await seedLesson(redis, 'redis:pool', { recall_count: 9, what_worked: 'set max_retries=3' });
+    const out = (await handleBrainTool('recall_best_solution', { instance_id: 'i1', topic: 'redis:pool' }, getConn, noopApiFetch))!;
+    expect(out).toContain('Battle-tested');
+    expect(out).toContain('recalled 10×');
+  });
+
+  it('shows "Proven" when recall_count is between 5 and 9', async () => {
+    await seedLesson(redis, 'api:auth', { recall_count: 4 });
+    const out = (await handleBrainTool('recall_best_solution', { instance_id: 'i1', topic: 'api:auth' }, getConn, noopApiFetch))!;
+    expect(out).toContain('Proven');
+    expect(out).toContain('recalled 5×');
+    expect(out).not.toContain('Battle-tested');
+  });
+
+  it('shows no trust badge for a fresh low-recall lesson', async () => {
+    await seedLesson(redis, 'misc:thing', { recall_count: 0 });
+    const out = (await handleBrainTool('recall_best_solution', { instance_id: 'i1', topic: 'misc:thing' }, getConn, noopApiFetch))!;
+    expect(out).not.toContain('Battle-tested');
+    expect(out).not.toContain('Proven —');
+    expect(out).not.toContain('Team-verified');
+  });
+
+  it('increments recall_count and persists it', async () => {
+    await seedLesson(redis, 'deploy:x', { recall_count: 2 });
+    await handleBrainTool('recall_best_solution', { instance_id: 'i1', topic: 'deploy:x' }, getConn, noopApiFetch);
+    const stored = JSON.parse((await redis.get('cachly:lesson:best:deploy:x'))!);
+    expect(stored.recall_count).toBe(3);
+  });
+});
+
+describe('Proven Laws crystallization (session_start)', () => {
+  let redis: MockRedis;
+  const getConn = async () => redis as unknown as Redis;
+  beforeEach(async () => {
+    redis = new MockRedis();
+    // Provide a last session so session_start does not attempt git reconstruction.
+    await redis.set('cachly:session:last', JSON.stringify({ summary: 'prior work', ts: new Date().toISOString(), files_changed: [] }));
+  });
+
+  it('surfaces lessons recalled >= 5 in the Proven Laws section', async () => {
+    await seedLesson(redis, 'infra:k3s', { recall_count: 7, what_worked: 'add WireGuard IP to TLS-SAN' });
+    await seedLesson(redis, 'random:note', { recall_count: 1 });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).toContain('Proven Laws');
+    expect(out).toContain('infra:k3s');
+    expect(out).toContain('recalled 7×');
+  });
+
+  it('surfaces an explicitly pinned lesson even with low recall', async () => {
+    await seedLesson(redis, 'team:convention', { recall_count: 0, pinned: true, what_worked: 'always snake_case handlers' });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).toContain('Proven Laws');
+    expect(out).toContain('team:convention');
+    expect(out).toContain('pinned');
+  });
+
+  it('omits the Proven Laws section when nothing qualifies', async () => {
+    await seedLesson(redis, 'small:thing', { recall_count: 1 });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).not.toContain('Proven Laws');
+  });
+
+  it('does not crystallize failure lessons', async () => {
+    await seedLesson(redis, 'broken:flow', { recall_count: 9, outcome: 'failure', what_failed: 'never works' });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).not.toContain('Proven Laws');
+  });
+});
+
+describe('Predictive pre-warning without explicit focus (session_start)', () => {
+  let redis: MockRedis;
+  const getConn = async () => redis as unknown as Redis;
+  beforeEach(() => { redis = new MockRedis(); });
+
+  it('derives danger area from last session files and warns', async () => {
+    // Last session touched payment files → likely to continue there.
+    await redis.set('cachly:session:last', JSON.stringify({
+      summary: 'worked on payment integration',
+      ts: new Date().toISOString(),
+      files_changed: ['api/payment/stripe_webhook.go'],
+    }));
+    // A known failure in the payment area.
+    await seedLesson(redis, 'payment:webhook', { outcome: 'failure', what_failed: 'missed idempotency key → double charge', tags: ['payment'] });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).toContain('PRE-WARNING');
+    expect(out).toContain('payment:webhook');
+  });
+
+  it('does not warn when last-session area has no known failures', async () => {
+    await redis.set('cachly:session:last', JSON.stringify({
+      summary: 'wrote docs',
+      ts: new Date().toISOString(),
+      files_changed: ['docs/readme.md'],
+    }));
+    await seedLesson(redis, 'payment:webhook', { outcome: 'failure', what_failed: 'x', tags: ['payment'] });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).not.toContain('PRE-WARNING');
+  });
+
+  it('filters path noise so common segments do not trigger false matches', async () => {
+    // Last session only touched generic noise paths (src/lib/index).
+    await redis.set('cachly:session:last', JSON.stringify({
+      summary: 'refactor',
+      ts: new Date().toISOString(),
+      files_changed: ['src/lib/index.ts'],
+    }));
+    // A failure tagged 'src' — should NOT match because 'src' is noise.
+    await seedLesson(redis, 'src:thing', { outcome: 'failure', what_failed: 'noise', tags: ['src'] });
+    const out = (await handleBrainTool('session_start', { instance_id: 'i1' }, getConn, noopApiFetch))!;
+    expect(out).not.toContain('PRE-WARNING');
+  });
+});

package/src/handlers/brain.ts

@@ -502,6 +502,22 @@ export async function handleBrainTool(
         10,
       );
 
+      // Increment recall_count on matched lessons (fire-and-forget — same as recall_best_solution).
+      // This ensures the dashboard metric, Proven Laws, and trust badges reflect real smart_recall usage.
+      const lessonMatches = kwMatches.filter(m => m.key.startsWith('cachly:lesson:best:'));
+      for (const m of lessonMatches.slice(0, 5)) {
+        const existing = await redis.get(m.key).catch(() => null);
+        if (existing) {
+          const lesson = safeJsonParse(existing, null as null | { recall_count?: number; [k: string]: unknown });
+          if (lesson) {
+            const updated = { ...lesson, recall_count: (lesson.recall_count ?? 0) + 1, verified_at: new Date().toISOString() };
+            redis.set(m.key, JSON.stringify(updated)).catch(() => {});
+            const savedMins = (lesson.severity as string) === 'critical' ? 240 : (lesson.severity as string) === 'major' ? 60 : 30;
+            redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => {});
+          }
+        }
+      }
+
       const lines: string[] = [`🧠 **Smart Recall** for: _"${query}"_\n`];
 
       // Show sub-query info if multi-topic was detected
@@ -916,6 +932,31 @@ export async function handleBrainTool(
       // Brain health
       lines.push(`📊 **Brain:** ${lessons.length} lessons · ${ctxCount} context entries`, '');
 
+      // ── 📌 Proven Laws — auto-crystallized lessons (quick win 3) ─────────────
+      // A lesson that has proven itself (recalled ≥ CRYSTALLIZE_RECALLS times) or
+      // was explicitly pinned becomes a "law" — surfaced at the top of every
+      // briefing so the most battle-tested knowledge is never buried. This is
+      // the today-safe version of swarm crystallization: enough confirmations
+      // auto-promote a lesson without any manual step.
+      {
+        type LessonPin = typeof lessons[0] & { pinned?: boolean };
+        const CRYSTALLIZE_RECALLS = 5;
+        const laws = (lessons as LessonPin[])
+          .filter(l => l.outcome === 'success' && (l.pinned === true || (l.recall_count ?? 0) >= CRYSTALLIZE_RECALLS))
+          .sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0))
+          .slice(0, 5);
+        if (laws.length > 0) {
+          lines.push(`📌 **Proven Laws** (auto-crystallized — your most-trusted knowledge):`);
+          for (const l of laws) {
+            const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
+            const rc  = l.recall_count ?? 0;
+            const why = l.pinned === true ? 'pinned' : `recalled ${rc}×`;
+            lines.push(`  🏆${sev} \`${l.topic}\` _(${why})_ — ${l.what_worked.slice(0, 100)}`);
+          }
+          lines.push('');
+        }
+      }
+
       // ── Layer 7: MCM Domain Coverage Map ────────────────────────────────────
       if (lessons.length >= 3) {
         const domainMap = new Map<string, { total: number; success: number; critical: number }>();

package/src/index.ts

@@ -60,7 +60,7 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 let JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.10.42';
+const CURRENT_VERSION = '0.10.44';
 
 // ── Default Instance Resolution (for Smithery & single-credential setups) ────
 // When CACHLY_BRAIN_INSTANCE_ID is set, tools can omit the instance_id parameter.
@@ -2156,6 +2156,7 @@ if (process.argv[2] === 'setup') {
     const CLIENT_ID = 'cachly-cli';
 
     console.log('Step 1: Sign in to cachly (free, no credit card)\n');
+    sendFunnelEvent('setup_auth_started');
 
     // Start device flow
     let deviceCode = '', userCode = '', verifyUri = '', pollInterval = 5000;
@@ -2179,6 +2180,7 @@ if (process.argv[2] === 'setup') {
       console.error('Falling back: sign in at https://cachly.dev/setup-ai and paste your API token.\n');
       token = await ask('   Paste API token (cky_live_...): ');
       if (!token) { console.error('\nToken is required. Aborting.\n'); rl.close(); process.exit(1); }
+      sendFunnelEvent('setup_auth_completed');
       console.log('');
       deviceCode = ''; // mark as fallback so we skip polling
     }
@@ -2212,6 +2214,7 @@ if (process.argv[2] === 'setup') {
           if (tokenData.access_token) {
             token = tokenData.access_token;
             console.log(' \x1b[32m✓ Authorized!\x1b[0m\n');
+            sendFunnelEvent('setup_auth_completed');
             break;
           }
           // authorization_pending = keep polling; slow_down = increase interval
@@ -2328,6 +2331,7 @@ if (process.argv[2] === 'setup') {
     console.log(`   (Run with --instance-id <id> to use a different one)\n`);
   }
   console.log(`✓  Instance: ${instance.name} (${instance.id.slice(0, 8)}…)\n`);
+  sendFunnelEvent('setup_instance_ready', { instance_id: instance.id });
 
   // ── Step 3: Detect editors ────────────────────────────────────────────────
   const cwd = process.cwd();