@cachly-dev/mcp-server 0.9.22 → 0.9.24

package/src/search.test.ts

@@ -606,4 +606,243 @@ describe('keywordSearch prefix-matching', () => {
   });
 });
 
+// ── tokenize edge cases ───────────────────────────────────────────────────────
+
+describe('tokenize — edge cases', () => {
+  it('handles pure numbers', () => {
+    const tokens = tokenize('404 500 200');
+    // Numbers are preserved as tokens if length > 1
+    expect(tokens.some(t => /\d/.test(t))).toBe(true);
+  });
+
+  it('handles URLs — strips protocol and splits on slashes', () => {
+    const tokens = tokenize('https://api.cachly.dev/v1/instances');
+    expect(tokens.some(t => t.includes('cachly') || t.includes('api') || t.includes('instances'))).toBe(true);
+  });
+
+  it('handles markdown formatting — strips asterisks and backticks', () => {
+    const tokens = tokenize('**Deploy** the `server` now');
+    expect(tokens).toContain('deploy');
+    expect(tokens).toContain('server');
+  });
+
+  it('deduplicates identical tokens (from cross-lingual expansion)', () => {
+    const tokens = tokenize('deploy deploy');
+    const counts: Record<string, number> = {};
+    for (const t of tokens) counts[t] = (counts[t] ?? 0) + 1;
+    // Exact duplicates are deduplicated
+    expect(counts['deploy'] ?? 0).toBeLessThanOrEqual(2);
+  });
+
+  it('handles very long single words (hashed to bigram)', () => {
+    const longWord = 'a'.repeat(50);
+    const tokens = tokenize(longWord);
+    // Should not crash and should produce at least one token
+    expect(tokens.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('handles emoji in text gracefully', () => {
+    const tokens = tokenize('🚀 deploy 🔥 server');
+    expect(tokens).toContain('deploy');
+    expect(tokens).toContain('server');
+  });
+
+  it('handles mixed script in single sentence', () => {
+    const tokens = tokenize('deploy サーバー to production 서버');
+    expect(tokens).toContain('deploy');
+    expect(tokens.some(t => t === 'server' || t.includes('sa') || t.includes('ba'))).toBe(true);
+  });
+});
+
+// ── levenshtein edge cases ────────────────────────────────────────────────────
+
+describe('levenshtein — additional cases', () => {
+  it('single character strings', () => {
+    expect(levenshtein('a', 'a')).toBe(0);
+    expect(levenshtein('a', 'b')).toBe(1);
+    expect(levenshtein('a', 'ab')).toBe(1);
+  });
+
+  it('symmetric property: d(a,b) === d(b,a)', () => {
+    const pairs: [string, string][] = [
+      ['deploy', 'deploi'],
+      ['hello', 'world'],
+      ['abc', ''],
+      ['redis', 'reds'],
+    ];
+    for (const [a, b] of pairs) {
+      expect(levenshtein(a, b)).toBe(levenshtein(b, a));
+    }
+  });
+
+  it('triangle inequality: d(a,c) ≤ d(a,b) + d(b,c)', () => {
+    const a = 'docker';
+    const b = 'doker';   // 1 edit from docker
+    const c = 'dcker';   // 1 edit from docker, 2 from doker
+    expect(levenshtein(a, c)).toBeLessThanOrEqual(levenshtein(a, b) + levenshtein(b, c));
+  });
+
+  it('common tech term typos are within distance 2', () => {
+    const typos: [string, string][] = [
+      ['docker', 'docekr'],
+      ['redis', 'redsi'],
+      ['nginx', 'nigx'],
+      ['postgres', 'posgres'],
+    ];
+    for (const [correct, typo] of typos) {
+      expect(levenshtein(correct, typo)).toBeLessThanOrEqual(2);
+    }
+  });
+});
+
+// ── recencyBoost edge cases ───────────────────────────────────────────────────
+
+describe('recencyBoost — additional cases', () => {
+  it('returns 1.0 for null/undefined', () => {
+    expect(recencyBoost(undefined)).toBe(1.0);
+    expect(recencyBoost(null as unknown as undefined)).toBe(1.0);
+  });
+
+  it('returns max boost (1.5) for timestamps in the future', () => {
+    const future = Date.now() + 60_000; // 1 minute ahead
+    const boost = recencyBoost(future);
+    expect(boost).toBeCloseTo(1.5, 1);
+  });
+
+  it('boost is consistent for same age', () => {
+    const ts = Date.now() - 2 * 86400000;
+    expect(recencyBoost(ts)).toBeCloseTo(recencyBoost(ts), 5);
+  });
+
+  it('boost values bracket correctly for known ages', () => {
+    const now = Date.now();
+    const fresh   = recencyBoost(now);                            // 0d
+    const oneDay  = recencyBoost(now - 86400000);                 // 1d
+    const fourDay = recencyBoost(now - 4 * 86400000);             // 4d
+    const weekOld = recencyBoost(now - 7 * 86400000);             // 7d
+    const monthOld = recencyBoost(now - 30 * 86400000);           // 30d
+    const yearOld  = recencyBoost(now - 365 * 86400000);          // 1y
+
+    expect(fresh).toBeGreaterThan(1.4);
+    expect(oneDay).toBeGreaterThan(1.2);
+    expect(fourDay).toBeGreaterThan(1.0);
+    expect(weekOld).toBeCloseTo(1.0, 1);
+    expect(monthOld).toBeLessThan(0.9);
+    expect(yearOld).toBeGreaterThanOrEqual(0.5);
+  });
+});
+
+// ── extractTimestamp edge cases ───────────────────────────────────────────────
+
+describe('extractTimestamp — additional cases', () => {
+  it('handles updated_at field', () => {
+    const content = '{"updated_at":"2026-05-01T10:00:00Z","key":"value"}';
+    const ts = extractTimestamp(content);
+    // Should find a valid date (updated_at or fall through to ts)
+    if (ts) {
+      expect(new Date(ts).getFullYear()).toBeGreaterThanOrEqual(2026);
+    }
+  });
+
+  it('extracts from nested JSON objects', () => {
+    const content = JSON.stringify({ meta: { ts: '2026-03-15T08:00:00Z' }, value: 'test' });
+    // ts is at top-level via regex so this might not match nested — just no crash
+    expect(() => extractTimestamp(content)).not.toThrow();
+  });
+
+  it('handles array-valued ts field gracefully', () => {
+    const content = '{"ts":[1,2,3],"data":"test"}';
+    expect(() => extractTimestamp(content)).not.toThrow();
+  });
+
+  it('handles partial JSON (truncated)', () => {
+    const content = '{"ts":"2026-01-01T00:00:00Z","data":"tr';
+    expect(() => extractTimestamp(content)).not.toThrow();
+  });
+
+  it('returns undefined for plain text with no JSON', () => {
+    expect(extractTimestamp('just a sentence with no dates')).toBeUndefined();
+  });
+});
+
+// ── splitMultiQuery completeness ──────────────────────────────────────────────
+
+describe('splitMultiQuery — additional splitters', () => {
+  it('splits "furthermore" (English)', () => {
+    const r = splitMultiQuery('fix timeout furthermore increase heap');
+    expect(r.length).toBe(2);
+  });
+
+  it('splits "additionally" (English)', () => {
+    const r = splitMultiQuery('deploy api additionally update config');
+    expect(r.length).toBe(2);
+  });
+
+  it('splits "de plus" (French)', () => {
+    const r = splitMultiQuery('déployer API de plus corriger timeout');
+    expect(r.length).toBe(2);
+  });
+
+  it('splits "und außerdem" (German)', () => {
+    const r = splitMultiQuery('API deployen und außerdem Timeout erhöhen');
+    expect(r.length).toBe(2);
+  });
+
+  it('handles input with only separators gracefully', () => {
+    const r = splitMultiQuery(';;;');
+    // Should not crash; may return empty or single element
+    expect(Array.isArray(r)).toBe(true);
+  });
+
+  it('does not split on comma inside brackets', () => {
+    // "1 item" shouldn't produce garbage splits
+    const r = splitMultiQuery('deploy API');
+    expect(r).toEqual(['deploy API']);
+  });
+
+  it('preserves query with no splitter', () => {
+    const q = 'find the best way to deploy docker containers';
+    expect(splitMultiQuery(q)).toEqual([q]);
+  });
+});
+
+// ── CROSS_LINGUAL_MAP completeness ────────────────────────────────────────────
+
+describe('CROSS_LINGUAL_MAP — coverage', () => {
+  const REQUIRED_EN_TERMS = [
+    'deploy', 'error', 'server', 'database', 'container',
+    'cache', 'authentication', 'timeout', 'memory', 'network',
+  ];
+
+  it.each(REQUIRED_EN_TERMS)('"%s" has cross-lingual entries', (term) => {
+    const entries = CROSS_LINGUAL_MAP.get(term);
+    expect(entries, `"${term}" missing from CROSS_LINGUAL_MAP`).toBeDefined();
+    expect(entries!.length).toBeGreaterThan(0);
+  });
+
+  it('all values are non-empty arrays of strings', () => {
+    for (const [key, values] of CROSS_LINGUAL_MAP.entries()) {
+      expect(Array.isArray(values), `Values for "${key}" are not an array`).toBe(true);
+      for (const v of values) {
+        expect(typeof v, `Value "${v}" for key "${key}" is not a string`).toBe('string');
+        expect(v.length, `Empty string in values for "${key}"`).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('bi-directional entries exist (reverse lookups)', () => {
+    // For each forward entry, the reverse should also exist
+    let reverseCount = 0;
+    for (const [key, values] of CROSS_LINGUAL_MAP.entries()) {
+      for (const v of values) {
+        if (CROSS_LINGUAL_MAP.has(v)) {
+          reverseCount++;
+        }
+      }
+    }
+    // A healthy map has substantial bidirectionality
+    expect(reverseCount).toBeGreaterThan(20);
+  });
+});
+
 

package/src/tools.ts

@@ -1158,9 +1158,12 @@ const TOOLS = [
   {
     name: 'invite_member',
     description:
+      'MUTATION — sends an invite email immediately and cannot be undone via MCP. ' +
       'Invite a team member to a Cachly organization by email. ' +
-      'They will receive an invite email and can join via the dashboard. ' +
-      'Roles: owner (full access), admin (manage members + instances), member (read + cache ops).',
+      'Requires the caller to be an admin or owner of the organization. ' +
+      'Valid roles: admin (manage members + instances), member (read + cache ops). Default role: member. ' +
+      'Returns an error if the email is already a member or has a pending invite.',
+    // NOTE: schema intentionally omits 'owner' — owners can only be set via the billing portal.
     inputSchema: {
       type: 'object',
       properties: {
@@ -1474,9 +1477,12 @@ const TOOLS = [
   {
     name: 'brain_predict',
     description:
-      'Predictive Pre-fetch Engine (PPE): given your current context (what you\'re working on), traverses the CKG ' +
-      'to predict likely failures and pre-load relevant fixes. Returns top predicted pitfalls + highest-confidence fixes. ' +
-      'Call at session_start when working on a specific feature or debugging area.',
+      'READ-ONLY — no side effects, no writes, no external network calls. ' +
+      'Predictive Pre-fetch Engine (PPE): given your current context, reads the CKG in your Redis instance ' +
+      'to predict likely failures and return the highest-confidence fixes. ' +
+      '"Pre-load" means results are returned inline — nothing is cached or persisted. ' +
+      'Requires a valid instance_id (your Redis brain). No rate limits. ' +
+      'Call at session start when working on a specific feature or debugging area.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1537,9 +1543,12 @@ const TOOLS = [
   {
     name: 'cls_install_hooks',
     description:
-      'Output a ready-to-install git post-commit hook + GitHub Actions step for Continuous Learning. ' +
-      'Once installed, every git commit and CI build automatically feeds the brain — no session_end needed. ' +
-      'Run once per repository.',
+      'READ-ONLY — outputs text only, writes no files, makes no network calls, has no side effects. ' +
+      'Generates ready-to-paste shell scripts: a git post-commit hook and/or a GitHub Actions step. ' +
+      'You must manually copy and install the output. ' +
+      'Once the generated scripts are installed, each git commit or CI run will make outbound HTTPS calls ' +
+      'to api.cachly.dev to feed learning signals to your brain. ' +
+      'No auth required to call this tool — only an instance_id. Run once per repository.',
     inputSchema: {
       type: 'object',
       properties: {