@cachly-dev/mcp-server 0.10.128 → 0.10.130

package/dist/src/handlers/cache.js

@@ -1,638 +1,59 @@
-import { randomUUID } from 'node:crypto';
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { readdir, stat, readFile } from 'node:fs/promises';
-import { join, relative, extname } from 'node:path';
-import { computeEmbedding, hasEmbedProvider, embedProviderHint } from '../embeddings.js';
-import { detectNamespace } from '../namespace.js';
-import { simpleHash } from '../confidence.js';
-import { scanKeys } from '../utils.js';
-import { cachlyUrl } from '../cachly-url.js';
-export const CACHE_TOOL_NAMES = new Set([
-    'cache_get', 'cache_set', 'cache_delete', 'cache_exists', 'cache_ttl', 'cache_keys',
-    'cache_stats', 'semantic_search', 'detect_namespace', 'cache_warmup', 'index_project',
-    'cache_mset', 'cache_mget', 'cache_lock_acquire', 'cache_lock_release',
-    'cache_stream_set', 'cache_stream_get', 'cache_org_stats', 'set_cost_per_call',
-]);
-export async function handleCacheTool(name, args, getConnection, apiFetch) {
-    switch (name) {
-        case 'cache_get': {
-            const { instance_id, key, org_id } = args;
-            const redis = await getConnection(instance_id);
-            let value = await redis.get(key);
-            let source = 'direct';
-            if (value === null && org_id) {
-                const orgKey = `org:${org_id}:sem:${key}`;
-                value = await redis.get(orgKey);
-                if (value !== null)
-                    source = `org:${org_id}:sem`;
-            }
-            if (value === null)
-                return `Key \`${key}\` → **not found** (null)`;
-            let pretty = value;
-            try {
-                pretty = JSON.stringify(JSON.parse(value), null, 2);
-            }
-            catch {
-                // not JSON — return raw
-            }
-            const sourceNote = source !== 'direct' ? ` _(from shared org namespace \`${source}\`)_` : '';
-            return `Key \`${key}\`:${sourceNote}\n\`\`\`\n${pretty}\n\`\`\``;
-        }
-        case 'cache_set': {
-            const { instance_id, key, value, ttl, org_id } = args;
-            const redis = await getConnection(instance_id);
-            if (ttl && ttl > 0) {
-                await redis.set(key, value, 'EX', ttl);
-                if (org_id) {
-                    await redis.set(`org:${org_id}:sem:${key}`, value, 'EX', ttl);
-                }
-                return `✅ Set \`${key}\` (TTL: ${ttl}s)${org_id ? ` + shared to \`org:${org_id}:sem\`` : ''}`;
-            }
-            await redis.set(key, value);
-            if (org_id) {
-                await redis.set(`org:${org_id}:sem:${key}`, value);
-            }
-            return `✅ Set \`${key}\` (no expiry)${org_id ? ` + shared to \`org:${org_id}:sem\`` : ''}`;
-        }
-        case 'cache_delete': {
-            const { instance_id, keys } = args;
-            const redis = await getConnection(instance_id);
-            const deleted = await redis.del(...keys);
-            return `✅ Deleted **${deleted}** of ${keys.length} key(s): ${keys.map((k) => `\`${k}\``).join(', ')}`;
-        }
-        case 'cache_exists': {
-            const { instance_id, keys } = args;
-            const redis = await getConnection(instance_id);
-            const count = await redis.exists(...keys);
-            return `**${count}** of ${keys.length} key(s) exist in cache.`;
-        }
-        case 'cache_ttl': {
-            const { instance_id, key } = args;
-            const redis = await getConnection(instance_id);
-            const ttl = await redis.ttl(key);
-            if (ttl === -2)
-                return `Key \`${key}\` → **does not exist**`;
-            if (ttl === -1)
-                return `Key \`${key}\` → **no expiry** (persists forever)`;
-            const mins = Math.floor(ttl / 60);
-            const secs = ttl % 60;
-            return `Key \`${key}\` → TTL: **${ttl}s** (${mins}m ${secs}s remaining)`;
-        }
-        case 'cache_keys': {
-            const { instance_id, pattern = '*', count = 50 } = args;
-            const limit = Math.min(count, 500);
-            const redis = await getConnection(instance_id);
-            const keys = [];
-            const stream = redis.scanStream({ match: pattern, count: 100 });
-            await new Promise((resolve, reject) => {
-                stream.on('data', (batch) => {
-                    keys.push(...batch);
-                    if (keys.length >= limit) {
-                        stream.destroy();
-                        resolve();
-                    }
-                });
-                stream.on('end', resolve);
-                stream.on('error', reject);
-            });
-            const result = keys.slice(0, limit);
-            if (result.length === 0)
-                return `No keys found matching pattern \`${pattern}\`.`;
-            return [
-                `Found **${result.length}** key(s) matching \`${pattern}\`:`,
-                ...result.map((k) => `  • \`${k}\``),
-                result.length === limit ? `\n_(showing first ${limit} — narrow pattern to see more)_` : '',
-            ]
-                .filter(Boolean)
-                .join('\n');
-        }
-        case 'cache_stats': {
-            const { instance_id } = args;
-            const redis = await getConnection(instance_id);
-            const [infoAll, infoStats, infoKeyspace] = await Promise.all([
-                redis.info('memory'),
-                redis.info('stats'),
-                redis.info('keyspace'),
-            ]);
-            const parse = (section, field) => section.match(new RegExp(`${field}:([^\r\n]+)`))?.[1]?.trim() ?? 'n/a';
-            const usedMem = parse(infoAll, 'used_memory_human');
-            const peakMem = parse(infoAll, 'used_memory_peak_human');
-            const hits = parse(infoStats, 'keyspace_hits');
-            const misses = parse(infoStats, 'keyspace_misses');
-            const opsPerSec = parse(infoStats, 'instantaneous_ops_per_sec');
-            const connectedClients = (await redis.info('clients')).match(/connected_clients:(\d+)/)?.[1] ?? 'n/a';
-            const hitsN = parseInt(hits) || 0;
-            const missesN = parseInt(misses) || 0;
-            const total = hitsN + missesN;
-            const hitRate = total > 0 ? ((hitsN / total) * 100).toFixed(1) : 'n/a';
-            const keyspaceLines = infoKeyspace
-                .split('\n')
-                .filter((l) => l.startsWith('db'))
-                .map((l) => `  ${l.trim()}`);
-            const lines = [
-                `📊 **Cache Stats for instance \`${instance_id}\`:**`,
-                ``,
-                `  💾 Memory used:   ${usedMem} (peak: ${peakMem})`,
-                `  ⚡ Ops/sec:       ${opsPerSec}`,
-                `  🎯 Hit rate:      ${hitRate}% (${hits} hits / ${misses} misses)`,
-                `  🔗 Clients:       ${connectedClients}`,
-                ``,
-                keyspaceLines.length > 0
-                    ? `  🗂️ Keyspace:\n${keyspaceLines.join('\n')}`
-                    : `  🗂️ Keyspace: (empty)`,
-            ];
-            try {
-                const inst = await apiFetch(`/api/v1/instances/${instance_id}`);
-                if (inst.vector_token) {
-                    const vectorBase = process.env.CACHLY_VECTOR_URL ?? 'https://api.cachly.dev';
-                    const statsRes = await fetch(`${vectorBase}/v1/sem/${inst.vector_token}/stats`, {
-                        signal: AbortSignal.timeout(5000),
-                    });
-                    if (statsRes.ok) {
-                        const data = await statsRes.json();
-                        const fmt = (n, decimals = 2) => n !== undefined ? n.toLocaleString('en-US', { minimumFractionDigits: decimals, maximumFractionDigits: decimals }) : 'n/a';
-                        const fmtInt = (n) => n !== undefined ? n.toLocaleString('en-US') : 'n/a';
-                        const totalHits = data.total_hits ?? 0;
-                        const totalEntries = data.total_entries ?? 0;
-                        if (totalHits === 0 && totalEntries === 0) {
-                            const proj = (devs) => (devs * 50 * 0.25 * 0.002 * 30).toFixed(2);
-                            lines.push(``, `💰 **Tokenmaxxing ROI — Projection:**`, `  📭 No cache hits yet — you're just getting started.`, ``, `  📊 Typical savings for your team size:`, `     5  devs × 50 LLM calls/day × 25% hit-rate → ~$${proj(5)}/month`, `     10 devs × 50 LLM calls/day × 25% hit-rate → ~$${proj(10)}/month`, `     20 devs × 50 LLM calls/day × 25% hit-rate → ~$${proj(20)}/month`, `     (Assumes avg $0.002/call saved per cache hit)`, ``, `  🚀 Next: route LLM calls through cachly to start accumulating hits.`, `     Docs: ${cachlyUrl('/docs/semantic', 'cache-stats')}`);
-                        }
-                        else {
-                            const wow = data.savings?.week_over_week_pct;
-                            const wowLine = wow !== undefined
-                                ? `  ${wow >= 0 ? '📈' : '📉'} 7d trend:          ${wow >= 0 ? '+' : ''}${wow.toFixed(1)}% vs prev week`
-                                : '';
-                            lines.push(``, `💰 **Tokenmaxxing ROI:**`, `  📦 Semantic entries:  ${fmtInt(data.total_entries)}`, `  🎯 Total cache hits:  ${fmtInt(data.total_hits)}`, `  ⏱️ Hits last 24h:     ${fmtInt(data.savings?.hits_last_24h)}`, `  📅 Hits last 7d:      ${fmtInt(data.savings?.hits_last_7d)}`, ...(wowLine ? [wowLine] : []), `  💵 Total saved:       $${fmt(data.savings?.estimated_total_saved_usd)}`, `  📈 Projected/month:   $${fmt(data.savings?.estimated_monthly_saved_usd)}`, `  📊 Avg per hit:       $${fmt(data.savings?.avg_cost_per_call_usd, 4)}`);
-                        }
-                        if (data.top_hits && data.top_hits.length > 0) {
-                            lines.push(``, `🔝 Top cached prompts:`);
-                            const topN = data.top_hits.slice(0, 3);
-                            topN.forEach((hit, i) => {
-                                const truncated = hit.prompt.length > 50 ? `${hit.prompt.slice(0, 50)}…` : hit.prompt;
-                                lines.push(`  ${i + 1}. "${truncated}" (hit ${hit.hit_count}×)`);
-                            });
-                        }
-                    }
-                }
-            }
-            catch {
-                // API unavailable or free tier — skip silently
-            }
-            return lines.join('\n');
-        }
-        case 'semantic_search': {
-            const { instance_id, query, threshold = 0.82, namespace: nsArg = 'cachly:sem', top_k = 5, use_hybrid = false, auto_namespace = false, } = args;
-            // resolve namespace from query text when requested
-            const namespace = auto_namespace ? detectNamespace(query) : nsArg;
-            if (!hasEmbedProvider()) {
-                return (`❌ semantic_search requires an embedding provider.\n\n` +
-                    `Current: ${embedProviderHint()}\n\n` +
-                    `Set one of these in your MCP env config:\n` +
-                    `  OPENAI_API_KEY   (provider: openai – default)\n` +
-                    `  MISTRAL_API_KEY  (provider: mistral)\n` +
-                    `  COHERE_API_KEY   (provider: cohere)\n` +
-                    `  GEMINI_API_KEY   (provider: gemini)\n` +
-                    `  OLLAMA_BASE_URL  (provider: ollama – local, no key needed)\n` +
-                    `Also set: CACHLY_EMBED_PROVIDER=<provider>`);
-            }
-            const inst = await apiFetch(`/api/v1/instances/${instance_id}`);
-            if (!inst.vector_token) {
-                return (`❌ Semantic search is only available on Speed and Business tiers.\n\n` +
-                    `Your instance "${inst.name}" is on the **${inst.tier.toUpperCase()}** tier.\n` +
-                    `Upgrade at ${cachlyUrl(`/instances/${instance_id}`, 'upgrade')}`);
-            }
-            // Compute embedding via configured provider
-            const embedding = await computeEmbedding(query);
-            // Query cachly vector API
-            const vectorUrl = process.env.CACHLY_VECTOR_URL ?? `https://api.cachly.dev/v1/sem/${inst.vector_token}`;
-            const searchPayload = { embedding, namespace, threshold, top_k };
-            // hybrid BM25+Vector RRF: include query text when requested.
-            if (use_hybrid) {
-                searchPayload['hybrid'] = true;
-                searchPayload['prompt'] = query;
-            }
-            const searchRes = await fetch(`${vectorUrl}/search`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(searchPayload),
-                signal: AbortSignal.timeout(8000),
-            });
-            if (!searchRes.ok) {
-                throw new McpError(ErrorCode.InternalError, `Vector search failed: ${searchRes.statusText}`);
-            }
-            const results = (await searchRes.json());
-            if (!results.length || (results.length === 1 && !results[0].found)) {
-                return (`🔍 No semantically similar entries found for:\n  _"${query}"_\n\n` +
-                    `Try lowering the threshold (current: ${threshold}) or using different keywords.`);
-            }
-            const redis = await getConnection(instance_id);
-            const lines = [
-                `🔍 **Semantic search results** for: _"${query}"_`,
-                `   Threshold: ${threshold} · Namespace: \`${namespace}\``,
-                ``,
-            ];
-            for (const hit of results) {
-                if (!hit.found || !hit.id)
-                    continue;
-                const value = await redis.get(`${namespace}:val:${hit.id}`);
-                lines.push(`**Match** (similarity: ${((hit.similarity ?? 0) * 100).toFixed(1)}%)`, `  Prompt: _"${hit.prompt ?? '(unknown)'}"_`, value ? `  Value:  \`${value.slice(0, 200)}${value.length > 200 ? '…' : ''}\`` : `  Value:  _(evicted from cache)_`, ``);
-            }
-            return lines.join('\n');
-        }
-        // ── Namespace Auto-Detection ──────────────────────────────────────────
-        case 'detect_namespace': {
-            const { prompt } = args;
-            const ns = detectNamespace(prompt);
-            const typeLabel = ns.split(':').pop();
-            const descriptions = {
-                code: '💻 Code — contains programming constructs or syntax',
-                translation: '🌐 Translation — asks to translate between languages',
-                summary: '📝 Summary — requests a summary or key points (TL;DR)',
-                qa: '❓ Q&A — a direct question or query',
-                creative: '🎨 Creative — general, creative, or conversational prompt',
-            };
-            return [
-                `**Detected namespace:** \`${ns}\``,
-                `**Type:** ${descriptions[typeLabel] ?? typeLabel}`,
-                ``,
-                `_Prompt: "${prompt.slice(0, 120)}${prompt.length > 120 ? '…' : ''}"_`,
-                ``,
-                `💡 Use this namespace in \`semantic_search\` or \`cache_warmup\` for better hit rates.`,
-                `   Set \`auto_namespace: true\` to apply this detection automatically.`,
-            ].join('\n');
-        }
-        // ── Cache Warmup ───────────────────────────────────────────────────────
-        case 'cache_warmup': {
-            const { instance_id, entries: rawEntries, namespace: nsArg = 'cachly:sem', ttl, auto_namespace = false, } = args;
-            if (!hasEmbedProvider()) {
-                return (`❌ cache_warmup requires an embedding provider.\n\n` +
-                    `Current: ${embedProviderHint()}\n\n` +
-                    `Supported: openai (default) · mistral · cohere · ollama (local) · gemini\n` +
-                    `Set CACHLY_EMBED_PROVIDER and the matching API key env var.`);
-            }
-            const inst = await apiFetch(`/api/v1/instances/${instance_id}`);
-            const vectorUrl = process.env.CACHLY_VECTOR_URL ??
-                (inst.vector_token ? `https://api.cachly.dev/v1/sem/${inst.vector_token}` : null);
-            const redis = await getConnection(instance_id);
-            let warmed = 0;
-            let skipped = 0;
-            const details = [];
-            for (const entry of rawEntries) {
-                // resolve namespace per entry
-                const ns = entry.namespace ?? (auto_namespace ? detectNamespace(entry.prompt) : nsArg);
-                // Compute embedding for this prompt
-                const embedding = await computeEmbedding(entry.prompt);
-                // Check if a very-similar entry already exists (threshold 0.98 → skip to avoid duplicates)
-                let alreadyCached = false;
-                if (vectorUrl) {
-                    const checkRes = await fetch(`${vectorUrl}/search`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ embedding, namespace: ns, threshold: 0.98 }),
-                        signal: AbortSignal.timeout(8000),
-                    }).catch(() => null);
-                    if (checkRes?.ok) {
-                        const results = (await checkRes.json());
-                        alreadyCached = results[0]?.found ?? false;
-                    }
-                }
-                if (alreadyCached) {
-                    skipped++;
-                    details.push(`  ⏭️  _"${entry.prompt.slice(0, 60)}${entry.prompt.length > 60 ? '…' : ''}"_ → already cached`);
-                    continue;
-                }
-                // Write value to Valkey
-                const id = randomUUID();
-                const vk = `${ns}:val:${id}`;
-                if (ttl && ttl > 0) {
-                    await redis.set(vk, entry.value, 'EX', ttl);
-                }
-                else {
-                    await redis.set(vk, entry.value);
-                }
-                if (vectorUrl) {
-                    // pgvector path – index embedding in HNSW
-                    const body = { id, prompt: entry.prompt, namespace: ns, embedding };
-                    if (ttl && ttl > 0) {
-                        body['expires_at'] = new Date(Date.now() + ttl * 1000).toISOString();
-                    }
-                    await fetch(`${vectorUrl}/entries`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify(body),
-                        signal: AbortSignal.timeout(8000),
-                    }).catch(() => undefined);
-                }
-                else {
-                    // Legacy SCAN path – write emb key to Valkey
-                    const embKey = `${ns}:emb:${id}`;
-                    const embPayload = JSON.stringify({ embedding, prompt: entry.prompt });
-                    if (ttl && ttl > 0) {
-                        await redis.set(embKey, embPayload, 'EX', ttl);
-                    }
-                    else {
-                        await redis.set(embKey, embPayload);
-                    }
-                }
-                warmed++;
-                details.push(`  ✅ _"${entry.prompt.slice(0, 60)}${entry.prompt.length > 60 ? '…' : ''}"_ → \`${ns}\``);
-            }
-            return [
-                `🔥 **Cache Warmup Complete**`,
-                ``,
-                `  ✅ Warmed:  **${warmed}** new entries`,
-                `  ⏭️  Skipped: **${skipped}** (already cached at ≥ 0.98 similarity)`,
-                `  📦 Total:   ${rawEntries.length}`,
-                auto_namespace
-                    ? `  🏷️  Namespacing: auto-detected per prompt`
-                    : `  🏷️  Namespace: \`${nsArg}\``,
-                vectorUrl
-                    ? `  🔍 Mode: pgvector HNSW (Speed/Business tier)`
-                    : `  🔍 Mode: Valkey SCAN (upgrade to Speed tier for scalable search)`,
-                ``,
-                ...details,
-            ].join('\n');
-        }
-        // ── index_project – Codebase Indexing ─────────────────────────────────────
-        case 'index_project': {
-            const { instance_id, dir, extensions: extArg, max_files = 100, ttl = 86400, summary_chars = 1200, namespace: nsArg = 'cachly:sem:code', } = args;
-            const ALLOWED_EXT = new Set((extArg ?? ['ts', 'js', 'tsx', 'jsx', 'go', 'py', 'java', 'rs', 'md', 'kt', 'swift']).map((e) => (e.startsWith('.') ? e : `.${e}`)));
-            // Recursively collect files up to max_files limit
-            const files = [];
-            async function walk(d) {
-                if (files.length >= max_files)
-                    return;
-                const entries = await readdir(d, { withFileTypes: true }).catch(() => null);
-                if (!entries)
-                    return;
-                for (const entry of entries) {
-                    if (files.length >= max_files)
-                        break;
-                    const full = join(d, entry.name);
-                    if (entry.isDirectory()) {
-                        if (['.git', 'node_modules', 'dist', 'build', '.next', '__pycache__', 'vendor'].includes(entry.name))
-                            continue;
-                        await walk(full);
-                    }
-                    else if (entry.isFile() && ALLOWED_EXT.has(extname(entry.name).toLowerCase())) {
-                        files.push(full);
-                    }
-                }
-            }
-            await walk(dir);
-            if (files.length === 0) {
-                return `❌ No matching files found in \`${dir}\`.\nExtensions checked: ${[...ALLOWED_EXT].join(', ')}`;
-            }
-            const inst = await apiFetch(`/api/v1/instances/${instance_id}`);
-            const vectorUrl = process.env.CACHLY_VECTOR_URL ??
-                (inst.vector_token ? `https://api.cachly.dev/v1/sem/${inst.vector_token}` : null);
-            const canEmbed = vectorUrl && hasEmbedProvider();
-            let indexed = 0;
-            let skipped = 0;
-            let errors = 0;
-            let semanticIndexed = 0;
-            let unchanged = 0;
-            const details = [];
-            const expiresAt = new Date(Date.now() + ttl * 1000).toISOString();
-            const redis = await getConnection(instance_id);
-            for (const filePath of files) {
-                const relPath = relative(dir, filePath);
-                let content;
-                let fileSize;
-                try {
-                    const s = await stat(filePath);
-                    if (s.size > 200_000) {
-                        skipped++;
-                        continue;
-                    } // skip files >200 KB
-                    fileSize = s.size;
-                    content = await readFile(filePath, 'utf-8');
-                }
-                catch {
-                    errors++;
-                    continue;
-                }
-                // ── Smart invalidation: hash-based change detection ──
-                // Compute a simple hash of file content to skip unchanged files
-                const hashKey = `cachly:idx:hash:${relPath}`;
-                const contentHash = `${fileSize}:${content.length}:${simpleHash(content)}`;
-                const existingHash = await redis.get(hashKey);
-                if (existingHash === contentHash) {
-                    // File unchanged — refresh TTL but skip re-indexing
-                    const idxKey = `cachly:idx:${relPath}`;
-                    if (ttl > 0)
-                        await redis.expire(idxKey, ttl);
-                    if (ttl > 0)
-                        await redis.expire(hashKey, ttl);
-                    unchanged++;
-                    continue;
-                }
-                const excerpt = content.slice(0, summary_chars).replace(/\s+/g, ' ').trim();
-                // ── Layer 1: Keyword index in Valkey (always works, no embedding needed) ──
-                const idxKey = `cachly:idx:${relPath}`;
-                const idxValue = `File: ${relPath}\n${excerpt}`;
-                if (ttl > 0) {
-                    await redis.set(idxKey, idxValue, 'EX', ttl);
-                }
-                else {
-                    await redis.set(idxKey, idxValue);
-                }
-                // Store content hash for smart invalidation on next run
-                if (ttl > 0) {
-                    await redis.set(hashKey, contentHash, 'EX', ttl);
-                }
-                else {
-                    await redis.set(hashKey, contentHash);
-                }
-                indexed++;
-                details.push(`  ✅ ${relPath}`);
-                // ── Layer 2: Semantic vector index (optional, only if embedding available) ──
-                if (canEmbed) {
-                    try {
-                        const prompt = `File: ${relPath}\n${excerpt}`;
-                        const embedding = await computeEmbedding(prompt);
-                        const id = randomUUID();
-                        await fetch(`${vectorUrl}/entries`, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({ id, prompt, namespace: nsArg, embedding, expires_at: expiresAt }),
-                            signal: AbortSignal.timeout(8000),
-                        });
-                        await redis.set(`${nsArg}:val:${id}`, relPath, 'EX', ttl);
-                        semanticIndexed++;
-                    }
-                    catch {
-                        // Semantic indexing failed — keyword index is enough
-                    }
-                }
-            }
-            const mode = canEmbed ? '🔍 Keyword + 🎯 Semantic' : '🔍 Keyword only (no embedding provider)';
-            return [
-                `📂 **index_project Complete** — ${mode}`,
-                ``,
-                `  📁 Dir:       ${dir}`,
-                `  ✅ Indexed:   **${indexed}** files (new/changed)`,
-                `  ♻️  Unchanged: ${unchanged} files (hash match — skipped)`,
-                ...(canEmbed ? [`  🎯 Semantic:  **${semanticIndexed}** files (vector-searchable)`] : []),
-                `  ⏭️  Skipped:   ${skipped} (too large or filtered)`,
-                `  ❌ Errors:    ${errors}`,
-                `  ⏱️  TTL:       ${ttl}s (${Math.round(ttl / 3600)}h)`,
-                ``,
-                `💡 **Next steps:**`,
-                `   1. Use \`smart_recall("how does auth work")\` to find relevant files.`,
-                `   2. Re-run index_project after major refactors.`,
-                ...(canEmbed ? [] : [`   3. Set OPENAI_API_KEY (or similar) in .env to also enable semantic search.`]),
-                ``,
-                ...(details.length <= 20 ? details : [...details.slice(0, 20), `  … and ${details.length - 20} more`]),
-            ].join('\n');
-        }
-        // ── Bulk / Lock / Stream tools ──────────────────────────────────────────
-        case 'cache_mset': {
-            const { instance_id, items } = args;
-            if (!Array.isArray(items) || items.length === 0)
-                return '⚠️ No items provided.';
-            const redis = await getConnection(instance_id);
-            const pipe = redis.pipeline();
-            for (const item of items) {
-                const serialized = typeof item.value === 'string' ? item.value : JSON.stringify(item.value);
-                if (item.ttl && item.ttl > 0) {
-                    pipe.set(item.key, serialized, 'EX', item.ttl);
-                }
-                else {
-                    pipe.set(item.key, serialized);
-                }
-            }
-            await pipe.exec();
-            return `✅ **cache_mset** – ${items.length} key(s) written in one pipeline round-trip.\n` +
-                items.map(i => `  • \`${i.key}\`${i.ttl ? ` (TTL ${i.ttl}s)` : ''}`).join('\n');
-        }
-        case 'cache_mget': {
-            const { instance_id, keys } = args;
-            if (!Array.isArray(keys) || keys.length === 0)
-                return '⚠️ No keys provided.';
-            const redis = await getConnection(instance_id);
-            const raws = await redis.mget(...keys);
-            const result = keys.map((k, i) => {
-                const raw = raws[i];
-                if (raw === null)
-                    return `  • \`${k}\`: _null (miss)_`;
-                return `  • \`${k}\`: ${raw}`;
-            });
-            return `✅ **cache_mget** – ${keys.length} key(s) fetched in one round-trip.\n` + result.join('\n');
-        }
-        case 'cache_lock_acquire': {
-            const { instance_id, key, ttl_ms = 5000, retries = 3, retry_delay_ms = 50 } = args;
-            const redis = await getConnection(instance_id);
-            const lockKey = `cachly:lock:${key}`;
-            const token = randomUUID();
-            for (let attempt = 0; attempt <= retries; attempt++) {
-                const result = await redis.set(lockKey, token, 'PX', ttl_ms, 'NX');
-                if (result === 'OK') {
-                    return `🔒 **cache_lock_acquire** – Lock acquired!\n\n  Key:   \`${key}\`\n  Token: \`${token}\`\n  TTL:   ${ttl_ms} ms\n\n💡 Use **cache_lock_release** with this token to release early.`;
-                }
-                if (attempt < retries)
-                    await new Promise(r => setTimeout(r, retry_delay_ms));
-            }
-            return `❌ **cache_lock_acquire** – Could not acquire lock for \`${key}\` after ${retries + 1} attempts.`;
-        }
-        case 'cache_lock_release': {
-            const { instance_id, key, token } = args;
-            const redis = await getConnection(instance_id);
-            const script = `if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end`;
-            const released = await redis.eval(script, 1, `cachly:lock:${key}`, token);
-            return released === 1
-                ? `🔓 **cache_lock_release** – Lock \`${key}\` released.`
-                : `⚠️ **cache_lock_release** – Lock \`${key}\` expired or token mismatch.`;
-        }
-        case 'cache_stream_set': {
-            const { instance_id, key, chunks, ttl } = args;
-            if (!Array.isArray(chunks) || chunks.length === 0)
-                return '⚠️ No chunks provided.';
-            const redis = await getConnection(instance_id);
-            const listKey = `cachly:stream:${key}`;
-            await redis.del(listKey);
-            const pipe = redis.pipeline();
-            for (const chunk of chunks)
-                pipe.rpush(listKey, chunk);
-            if (ttl && ttl > 0)
-                pipe.expire(listKey, ttl);
-            await pipe.exec();
-            return `✅ **cache_stream_set** – ${chunks.length} chunk(s) stored.\n  Key: \`${key}\`\n${ttl ? `  TTL: ${ttl}s\n` : ''}  Total size: ${chunks.reduce((a, c) => a + c.length, 0)} chars`;
-        }
-        case 'cache_stream_get': {
-            const { instance_id, key } = args;
-            const redis = await getConnection(instance_id);
-            const listKey = `cachly:stream:${key}`;
-            const len = await redis.llen(listKey);
-            if (len === 0)
-                return `⚠️ **cache_stream_get** – Cache miss for key \`${key}\`.`;
-            const chunks = await redis.lrange(listKey, 0, -1);
-            const full = chunks.join('');
-            const preview = full.slice(0, 500);
-            return `✅ **cache_stream_get** – ${len} chunk(s) retrieved for \`${key}\`.\n\n**Preview** (first 500 chars):\n\`\`\`\n${preview}${preview.length < full.length ? '…' : ''}\n\`\`\``;
-        }
-        case 'cache_org_stats': {
-            const { instance_id, org_id } = args;
-            const redis = await getConnection(instance_id);
-            const namespace = `org:${org_id}:sem`;
-            const keys = await scanKeys(redis, `${namespace}:*`, { max: 10000, timeoutMs: 5000 });
-            const entryCount = keys.length;
-            const lines = [
-                `🏢 Org Cache Stats for org \`${org_id}\`:`,
-                `  📦 Shared entries:  ${entryCount}`,
-                `  🔑 Namespace:       ${namespace}`,
-                `  👥 Benefit:         All instances sharing this org_id serve from the same cache`,
-                ``,
-                `💡 To enable sharing: set org_id="${org_id}" in cache_set calls`,
-            ];
-            // Org-wide savings aggregation (API endpoint may not be deployed yet,
-            // or the caller may not be an org member — fail silently in that case).
-            try {
-                const savings = await apiFetch(`/api/v1/orgs/${org_id}/savings`);
-                const usd = (n) => `$${(n ?? 0).toFixed(2)}`;
-                lines.push(``, `💰 Org-wide Tokenmaxxing ROI:`, `  🖥️ Instances:        ${savings.instance_count}`, `  🎯 Total cache hits:  ${savings.total_hits.toLocaleString('en-US')}`, `  ⏱️ Hits last 24h:     ${savings.hits_last_24h.toLocaleString('en-US')}`, `  💵 Total saved:       ${usd(savings.estimated_total_saved_usd)}`, `  📈 Projected/month:   ${usd(savings.estimated_monthly_saved_usd)}`);
-                const top = [...(savings.per_instance ?? [])]
-                    .sort((a, b) => b.estimated_total_saved_usd - a.estimated_total_saved_usd)
-                    .slice(0, 5);
-                if (top.length > 0) {
-                    lines.push(``, `  Top instances by savings:`);
-                    for (const inst of top) {
-                        lines.push(`    • ${inst.name || inst.instance_id}: ${usd(inst.estimated_total_saved_usd)} (${inst.total_hits.toLocaleString('en-US')} hits)`);
-                    }
-                }
-            }
-            catch {
-                // Endpoint unavailable / not a member / network error → Redis-only output.
-            }
-            return lines.join('\n');
-        }
-        case 'set_cost_per_call': {
-            const { instance_id, cost_per_call_usd } = args;
-            if (!cost_per_call_usd || cost_per_call_usd <= 0 || cost_per_call_usd > 100) {
-                throw new McpError(ErrorCode.InvalidParams, 'cost_per_call_usd must be a positive number ≤ 100');
-            }
-            await apiFetch(`/api/v1/instances/${instance_id}/cost-per-call`, {
-                method: 'PUT',
-                body: JSON.stringify({ cost_per_call_usd }),
-            });
-            const examples = {
-                '0.02': 'claude-opus-4.8',
-                '0.015': 'gpt-5.5',
-                '0.009': 'claude-sonnet-4.6',
-                '0.002': 'gpt-5.5-mini',
-                '0.001': 'claude-haiku-4.5',
-            };
-            const modelHint = examples[cost_per_call_usd.toString()] ? ` (${examples[cost_per_call_usd.toString()]})` : '';
-            return [
-                `✅ **Cost per call updated** — $${cost_per_call_usd.toFixed(4)}${modelHint}`,
-                ``,
-                `ROI savings in \`cache_stats\` will now use $${cost_per_call_usd.toFixed(4)} per avoided LLM call.`,
-                `Run \`cache_stats\` to see your updated savings estimate.`,
-            ].join('\n');
-        }
-        default:
-            return null;
-    }
-}
-//# sourceMappingURL=cache.js.map
+import{randomUUID as P}from"node:crypto";import{McpError as D,ErrorCode as Y}from"@modelcontextprotocol/sdk/types.js";import{readdir as J,stat as B,readFile as z}from"node:fs/promises";import{join as W,relative as G,extname as Q}from"node:path";import{computeEmbedding as C,hasEmbedProvider as K,embedProviderHint as q}from"../embeddings.js";import{detectNamespace as I}from"../namespace.js";import{simpleHash as Z}from"../confidence.js";import{scanKeys as ee}from"../utils.js";import{cachlyUrl as V}from"../cachly-url.js";const de=new Set(["cache_get","cache_set","cache_delete","cache_exists","cache_ttl","cache_keys","cache_stats","semantic_search","detect_namespace","cache_warmup","index_project","cache_mset","cache_mget","cache_lock_acquire","cache_lock_release","cache_stream_set","cache_stream_get","cache_org_stats","set_cost_per_call"]);async function he(X,p,u,O){switch(X){case"cache_get":{const{instance_id:n,key:e,org_id:a}=p,t=await u(n);let s=await t.get(e),i="direct";if(s===null&&a){const r=`org:${a}:sem:${e}`;s=await t.get(r),s!==null&&(i=`org:${a}:sem`)}if(s===null)return`Key \`${e}\` \u2192 **not found** (null)`;let c=s;try{c=JSON.stringify(JSON.parse(s),null,2)}catch{}const o=i!=="direct"?` _(from shared org namespace \`${i}\`)_`:"";return`Key \`${e}\`:${o}
+\`\`\`
+${c}
+\`\`\``}case"cache_set":{const{instance_id:n,key:e,value:a,ttl:t,org_id:s}=p,i=await u(n);return t&&t>0?(await i.set(e,a,"EX",t),s&&await i.set(`org:${s}:sem:${e}`,a,"EX",t),`\u2705 Set \`${e}\` (TTL: ${t}s)${s?` + shared to \`org:${s}:sem\``:""}`):(await i.set(e,a),s&&await i.set(`org:${s}:sem:${e}`,a),`\u2705 Set \`${e}\` (no expiry)${s?` + shared to \`org:${s}:sem\``:""}`)}case"cache_delete":{const{instance_id:n,keys:e}=p;return`\u2705 Deleted **${await(await u(n)).del(...e)}** of ${e.length} key(s): ${e.map(s=>`\`${s}\``).join(", ")}`}case"cache_exists":{const{instance_id:n,keys:e}=p;return`**${await(await u(n)).exists(...e)}** of ${e.length} key(s) exist in cache.`}case"cache_ttl":{const{instance_id:n,key:e}=p,t=await(await u(n)).ttl(e);if(t===-2)return`Key \`${e}\` \u2192 **does not exist**`;if(t===-1)return`Key \`${e}\` \u2192 **no expiry** (persists forever)`;const s=Math.floor(t/60),i=t%60;return`Key \`${e}\` \u2192 TTL: **${t}s** (${s}m ${i}s remaining)`}case"cache_keys":{const{instance_id:n,pattern:e="*",count:a=50}=p,t=Math.min(a,500),s=await u(n),i=[],c=s.scanStream({match:e,count:100});await new Promise((r,f)=>{c.on("data",l=>{i.push(...l),i.length>=t&&(c.destroy(),r())}),c.on("end",r),c.on("error",f)});const o=i.slice(0,t);return o.length===0?`No keys found matching pattern \`${e}\`.`:[`Found **${o.length}** key(s) matching \`${e}\`:`,...o.map(r=>`  \u2022 \`${r}\``),o.length===t?`
+_(showing first ${t} \u2014 narrow pattern to see more)_`:""].filter(Boolean).join(`
+`)}case"cache_stats":{const{instance_id:n}=p,e=await u(n),[a,t,s]=await Promise.all([e.info("memory"),e.info("stats"),e.info("keyspace")]),i=(_,j)=>_.match(new RegExp(`${j}:([^\r
+]+)`))?.[1]?.trim()??"n/a",c=i(a,"used_memory_human"),o=i(a,"used_memory_peak_human"),r=i(t,"keyspace_hits"),f=i(t,"keyspace_misses"),l=i(t,"instantaneous_ops_per_sec"),d=(await e.info("clients")).match(/connected_clients:(\d+)/)?.[1]??"n/a",$=parseInt(r)||0,S=parseInt(f)||0,L=$+S,T=L>0?($/L*100).toFixed(1):"n/a",w=s.split(`
+`).filter(_=>_.startsWith("db")).map(_=>`  ${_.trim()}`),h=[`\u{1F4CA} **Cache Stats for instance \`${n}\`:**`,"",`  \u{1F4BE} Memory used:   ${c} (peak: ${o})`,`  \u26A1 Ops/sec:       ${l}`,`  \u{1F3AF} Hit rate:      ${T}% (${r} hits / ${f} misses)`,`  \u{1F517} Clients:       ${d}`,"",w.length>0?`  \u{1F5C2}\uFE0F Keyspace:
+${w.join(`
+`)}`:"  \u{1F5C2}\uFE0F Keyspace: (empty)"];try{const _=await O(`/api/v1/instances/${n}`);if(_.vector_token){const j=process.env.CACHLY_VECTOR_URL??"https://api.cachly.dev",E=await fetch(`${j}/v1/sem/${_.vector_token}/stats`,{signal:AbortSignal.timeout(5e3)});if(E.ok){const v=await E.json(),k=(m,y=2)=>m!==void 0?m.toLocaleString("en-US",{minimumFractionDigits:y,maximumFractionDigits:y}):"n/a",g=m=>m!==void 0?m.toLocaleString("en-US"):"n/a",x=v.total_hits??0,A=v.total_entries??0;if(x===0&&A===0){const m=y=>(y*50*.25*.002*30).toFixed(2);h.push("","\u{1F4B0} **Tokenmaxxing ROI \u2014 Projection:**","  \u{1F4ED} No cache hits yet \u2014 you're just getting started.","","  \u{1F4CA} Typical savings for your team size:",`     5  devs \xD7 50 LLM calls/day \xD7 25% hit-rate \u2192 ~$${m(5)}/month`,`     10 devs \xD7 50 LLM calls/day \xD7 25% hit-rate \u2192 ~$${m(10)}/month`,`     20 devs \xD7 50 LLM calls/day \xD7 25% hit-rate \u2192 ~$${m(20)}/month`,"     (Assumes avg $0.002/call saved per cache hit)","","  \u{1F680} Next: route LLM calls through cachly to start accumulating hits.",`     Docs: ${V("/docs/semantic","cache-stats")}`)}else{const m=v.savings?.week_over_week_pct,y=m!==void 0?`  ${m>=0?"\u{1F4C8}":"\u{1F4C9}"} 7d trend:          ${m>=0?"+":""}${m.toFixed(1)}% vs prev week`:"";h.push("","\u{1F4B0} **Tokenmaxxing ROI:**",`  \u{1F4E6} Semantic entries:  ${g(v.total_entries)}`,`  \u{1F3AF} Total cache hits:  ${g(v.total_hits)}`,`  \u23F1\uFE0F Hits last 24h:     ${g(v.savings?.hits_last_24h)}`,`  \u{1F4C5} Hits last 7d:      ${g(v.savings?.hits_last_7d)}`,...y?[y]:[],`  \u{1F4B5} Total saved:       $${k(v.savings?.estimated_total_saved_usd)}`,`  \u{1F4C8} Projected/month:   $${k(v.savings?.estimated_monthly_saved_usd)}`,`  \u{1F4CA} Avg per hit:       $${k(v.savings?.avg_cost_per_call_usd,4)}`)}v.top_hits&&v.top_hits.length>0&&(h.push("","\u{1F51D} Top cached prompts:"),v.top_hits.slice(0,3).forEach((y,R)=>{const N=y.prompt.length>50?`${y.prompt.slice(0,50)}\u2026`:y.prompt;h.push(`  ${R+1}. "${N}" (hit ${y.hit_count}\xD7)`)}))}}}catch{}return h.join(`
+`)}case"semantic_search":{const{instance_id:n,query:e,threshold:a=.82,namespace:t="cachly:sem",top_k:s=5,use_hybrid:i=!1,auto_namespace:c=!1}=p,o=c?I(e):t;if(!K())return`\u274C semantic_search requires an embedding provider.
+
+Current: ${q()}
+
+Set one of these in your MCP env config:
+  OPENAI_API_KEY   (provider: openai \u2013 default)
+  MISTRAL_API_KEY  (provider: mistral)
+  COHERE_API_KEY   (provider: cohere)
+  GEMINI_API_KEY   (provider: gemini)
+  OLLAMA_BASE_URL  (provider: ollama \u2013 local, no key needed)
+Also set: CACHLY_EMBED_PROVIDER=<provider>`;const r=await O(`/api/v1/instances/${n}`);if(!r.vector_token)return`\u274C Semantic search is only available on Speed and Business tiers.
+
+Your instance "${r.name}" is on the **${r.tier.toUpperCase()}** tier.
+Upgrade at ${V(`/instances/${n}`,"upgrade")}`;const f=await C(e),l=process.env.CACHLY_VECTOR_URL??`https://api.cachly.dev/v1/sem/${r.vector_token}`,d={embedding:f,namespace:o,threshold:a,top_k:s};i&&(d.hybrid=!0,d.prompt=e);const $=await fetch(`${l}/search`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(d),signal:AbortSignal.timeout(8e3)});if(!$.ok)throw new D(Y.InternalError,`Vector search failed: ${$.statusText}`);const S=await $.json();if(!S.length||S.length===1&&!S[0].found)return`\u{1F50D} No semantically similar entries found for:
+  _"${e}"_
+
+Try lowering the threshold (current: ${a}) or using different keywords.`;const L=await u(n),T=[`\u{1F50D} **Semantic search results** for: _"${e}"_`,`   Threshold: ${a} \xB7 Namespace: \`${o}\``,""];for(const w of S){if(!w.found||!w.id)continue;const h=await L.get(`${o}:val:${w.id}`);T.push(`**Match** (similarity: ${((w.similarity??0)*100).toFixed(1)}%)`,`  Prompt: _"${w.prompt??"(unknown)"}"_`,h?`  Value:  \`${h.slice(0,200)}${h.length>200?"\u2026":""}\``:"  Value:  _(evicted from cache)_","")}return T.join(`
+`)}case"detect_namespace":{const{prompt:n}=p,e=I(n),a=e.split(":").pop(),t={code:"\u{1F4BB} Code \u2014 contains programming constructs or syntax",translation:"\u{1F310} Translation \u2014 asks to translate between languages",summary:"\u{1F4DD} Summary \u2014 requests a summary or key points (TL;DR)",qa:"\u2753 Q&A \u2014 a direct question or query",creative:"\u{1F3A8} Creative \u2014 general, creative, or conversational prompt"};return[`**Detected namespace:** \`${e}\``,`**Type:** ${t[a]??a}`,"",`_Prompt: "${n.slice(0,120)}${n.length>120?"\u2026":""}"_`,"","\u{1F4A1} Use this namespace in `semantic_search` or `cache_warmup` for better hit rates.","   Set `auto_namespace: true` to apply this detection automatically."].join(`
+`)}case"cache_warmup":{const{instance_id:n,entries:e,namespace:a="cachly:sem",ttl:t,auto_namespace:s=!1}=p;if(!K())return`\u274C cache_warmup requires an embedding provider.
+
+Current: ${q()}
+
+Supported: openai (default) \xB7 mistral \xB7 cohere \xB7 ollama (local) \xB7 gemini
+Set CACHLY_EMBED_PROVIDER and the matching API key env var.`;const i=await O(`/api/v1/instances/${n}`),c=process.env.CACHLY_VECTOR_URL??(i.vector_token?`https://api.cachly.dev/v1/sem/${i.vector_token}`:null),o=await u(n);let r=0,f=0;const l=[];for(const d of e){const $=d.namespace??(s?I(d.prompt):a),S=await C(d.prompt);let L=!1;if(c){const h=await fetch(`${c}/search`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({embedding:S,namespace:$,threshold:.98}),signal:AbortSignal.timeout(8e3)}).catch(()=>null);h?.ok&&(L=(await h.json())[0]?.found??!1)}if(L){f++,l.push(`  \u23ED\uFE0F  _"${d.prompt.slice(0,60)}${d.prompt.length>60?"\u2026":""}"_ \u2192 already cached`);continue}const T=P(),w=`${$}:val:${T}`;if(t&&t>0?await o.set(w,d.value,"EX",t):await o.set(w,d.value),c){const h={id:T,prompt:d.prompt,namespace:$,embedding:S};t&&t>0&&(h.expires_at=new Date(Date.now()+t*1e3).toISOString()),await fetch(`${c}/entries`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(h),signal:AbortSignal.timeout(8e3)}).catch(()=>{})}else{const h=`${$}:emb:${T}`,_=JSON.stringify({embedding:S,prompt:d.prompt});t&&t>0?await o.set(h,_,"EX",t):await o.set(h,_)}r++,l.push(`  \u2705 _"${d.prompt.slice(0,60)}${d.prompt.length>60?"\u2026":""}"_ \u2192 \`${$}\``)}return["\u{1F525} **Cache Warmup Complete**","",`  \u2705 Warmed:  **${r}** new entries`,`  \u23ED\uFE0F  Skipped: **${f}** (already cached at \u2265 0.98 similarity)`,`  \u{1F4E6} Total:   ${e.length}`,s?"  \u{1F3F7}\uFE0F  Namespacing: auto-detected per prompt":`  \u{1F3F7}\uFE0F  Namespace: \`${a}\``,c?"  \u{1F50D} Mode: pgvector HNSW (Speed/Business tier)":"  \u{1F50D} Mode: Valkey SCAN (upgrade to Speed tier for scalable search)","",...l].join(`
+`)}case"index_project":{const{instance_id:n,dir:e,extensions:a,max_files:t=100,ttl:s=86400,summary_chars:i=1200,namespace:c="cachly:sem:code"}=p,o=new Set((a??["ts","js","tsx","jsx","go","py","java","rs","md","kt","swift"]).map(k=>k.startsWith(".")?k:`.${k}`)),r=[];async function f(k){if(r.length>=t)return;const g=await J(k,{withFileTypes:!0}).catch(()=>null);if(g)for(const x of g){if(r.length>=t)break;const A=W(k,x.name);if(x.isDirectory()){if([".git","node_modules","dist","build",".next","__pycache__","vendor"].includes(x.name))continue;await f(A)}else x.isFile()&&o.has(Q(x.name).toLowerCase())&&r.push(A)}}if(await f(e),r.length===0)return`\u274C No matching files found in \`${e}\`.
+Extensions checked: ${[...o].join(", ")}`;const l=await O(`/api/v1/instances/${n}`),d=process.env.CACHLY_VECTOR_URL??(l.vector_token?`https://api.cachly.dev/v1/sem/${l.vector_token}`:null),$=d&&K();let S=0,L=0,T=0,w=0,h=0;const _=[],j=new Date(Date.now()+s*1e3).toISOString(),E=await u(n);for(const k of r){const g=G(e,k);let x,A;try{const b=await B(k);if(b.size>2e5){L++;continue}A=b.size,x=await z(k,"utf-8")}catch{T++;continue}const m=`cachly:idx:hash:${g}`,y=`${A}:${x.length}:${Z(x)}`;if(await E.get(m)===y){const b=`cachly:idx:${g}`;s>0&&await E.expire(b,s),s>0&&await E.expire(m,s),h++;continue}const N=x.slice(0,i).replace(/\s+/g," ").trim(),M=`cachly:idx:${g}`,U=`File: ${g}
+${N}`;if(s>0?await E.set(M,U,"EX",s):await E.set(M,U),s>0?await E.set(m,y,"EX",s):await E.set(m,y),S++,_.push(`  \u2705 ${g}`),$)try{const b=`File: ${g}
+${N}`,F=await C(b),H=P();await fetch(`${d}/entries`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({id:H,prompt:b,namespace:c,embedding:F,expires_at:j}),signal:AbortSignal.timeout(8e3)}),await E.set(`${c}:val:${H}`,g,"EX",s),w++}catch{}}return[`\u{1F4C2} **index_project Complete** \u2014 ${$?"\u{1F50D} Keyword + \u{1F3AF} Semantic":"\u{1F50D} Keyword only (no embedding provider)"}`,"",`  \u{1F4C1} Dir:       ${e}`,`  \u2705 Indexed:   **${S}** files (new/changed)`,`  \u267B\uFE0F  Unchanged: ${h} files (hash match \u2014 skipped)`,...$?[`  \u{1F3AF} Semantic:  **${w}** files (vector-searchable)`]:[],`  \u23ED\uFE0F  Skipped:   ${L} (too large or filtered)`,`  \u274C Errors:    ${T}`,`  \u23F1\uFE0F  TTL:       ${s}s (${Math.round(s/3600)}h)`,"","\u{1F4A1} **Next steps:**",'   1. Use `smart_recall("how does auth work")` to find relevant files.',"   2. Re-run index_project after major refactors.",...$?[]:["   3. Set OPENAI_API_KEY (or similar) in .env to also enable semantic search."],"",..._.length<=20?_:[..._.slice(0,20),`  \u2026 and ${_.length-20} more`]].join(`
+`)}case"cache_mset":{const{instance_id:n,items:e}=p;if(!Array.isArray(e)||e.length===0)return"\u26A0\uFE0F No items provided.";const t=(await u(n)).pipeline();for(const s of e){const i=typeof s.value=="string"?s.value:JSON.stringify(s.value);s.ttl&&s.ttl>0?t.set(s.key,i,"EX",s.ttl):t.set(s.key,i)}return await t.exec(),`\u2705 **cache_mset** \u2013 ${e.length} key(s) written in one pipeline round-trip.
+`+e.map(s=>`  \u2022 \`${s.key}\`${s.ttl?` (TTL ${s.ttl}s)`:""}`).join(`
+`)}case"cache_mget":{const{instance_id:n,keys:e}=p;if(!Array.isArray(e)||e.length===0)return"\u26A0\uFE0F No keys provided.";const t=await(await u(n)).mget(...e),s=e.map((i,c)=>{const o=t[c];return o===null?`  \u2022 \`${i}\`: _null (miss)_`:`  \u2022 \`${i}\`: ${o}`});return`\u2705 **cache_mget** \u2013 ${e.length} key(s) fetched in one round-trip.
+`+s.join(`
+`)}case"cache_lock_acquire":{const{instance_id:n,key:e,ttl_ms:a=5e3,retries:t=3,retry_delay_ms:s=50}=p,i=await u(n),c=`cachly:lock:${e}`,o=P();for(let r=0;r<=t;r++){if(await i.set(c,o,"PX",a,"NX")==="OK")return`\u{1F512} **cache_lock_acquire** \u2013 Lock acquired!
+
+  Key:   \`${e}\`
+  Token: \`${o}\`
+  TTL:   ${a} ms
+
+\u{1F4A1} Use **cache_lock_release** with this token to release early.`;r<t&&await new Promise(l=>setTimeout(l,s))}return`\u274C **cache_lock_acquire** \u2013 Could not acquire lock for \`${e}\` after ${t+1} attempts.`}case"cache_lock_release":{const{instance_id:n,key:e,token:a}=p;return await(await u(n)).eval('if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end',1,`cachly:lock:${e}`,a)===1?`\u{1F513} **cache_lock_release** \u2013 Lock \`${e}\` released.`:`\u26A0\uFE0F **cache_lock_release** \u2013 Lock \`${e}\` expired or token mismatch.`}case"cache_stream_set":{const{instance_id:n,key:e,chunks:a,ttl:t}=p;if(!Array.isArray(a)||a.length===0)return"\u26A0\uFE0F No chunks provided.";const s=await u(n),i=`cachly:stream:${e}`;await s.del(i);const c=s.pipeline();for(const o of a)c.rpush(i,o);return t&&t>0&&c.expire(i,t),await c.exec(),`\u2705 **cache_stream_set** \u2013 ${a.length} chunk(s) stored.
+  Key: \`${e}\`
+${t?`  TTL: ${t}s
+`:""}  Total size: ${a.reduce((o,r)=>o+r.length,0)} chars`}case"cache_stream_get":{const{instance_id:n,key:e}=p,a=await u(n),t=`cachly:stream:${e}`,s=await a.llen(t);if(s===0)return`\u26A0\uFE0F **cache_stream_get** \u2013 Cache miss for key \`${e}\`.`;const c=(await a.lrange(t,0,-1)).join(""),o=c.slice(0,500);return`\u2705 **cache_stream_get** \u2013 ${s} chunk(s) retrieved for \`${e}\`.
+
+**Preview** (first 500 chars):
+\`\`\`
+${o}${o.length<c.length?"\u2026":""}
+\`\`\``}case"cache_org_stats":{const{instance_id:n,org_id:e}=p,a=await u(n),t=`org:${e}:sem`,i=(await ee(a,`${t}:*`,{max:1e4,timeoutMs:5e3})).length,c=[`\u{1F3E2} Org Cache Stats for org \`${e}\`:`,`  \u{1F4E6} Shared entries:  ${i}`,`  \u{1F511} Namespace:       ${t}`,"  \u{1F465} Benefit:         All instances sharing this org_id serve from the same cache","",`\u{1F4A1} To enable sharing: set org_id="${e}" in cache_set calls`];try{const o=await O(`/api/v1/orgs/${e}/savings`),r=l=>`$${(l??0).toFixed(2)}`;c.push("","\u{1F4B0} Org-wide Tokenmaxxing ROI:",`  \u{1F5A5}\uFE0F Instances:        ${o.instance_count}`,`  \u{1F3AF} Total cache hits:  ${o.total_hits.toLocaleString("en-US")}`,`  \u23F1\uFE0F Hits last 24h:     ${o.hits_last_24h.toLocaleString("en-US")}`,`  \u{1F4B5} Total saved:       ${r(o.estimated_total_saved_usd)}`,`  \u{1F4C8} Projected/month:   ${r(o.estimated_monthly_saved_usd)}`);const f=[...o.per_instance??[]].sort((l,d)=>d.estimated_total_saved_usd-l.estimated_total_saved_usd).slice(0,5);if(f.length>0){c.push("","  Top instances by savings:");for(const l of f)c.push(`    \u2022 ${l.name||l.instance_id}: ${r(l.estimated_total_saved_usd)} (${l.total_hits.toLocaleString("en-US")} hits)`)}}catch{}return c.join(`
+`)}case"set_cost_per_call":{const{instance_id:n,cost_per_call_usd:e}=p;if(!e||e<=0||e>100)throw new D(Y.InvalidParams,"cost_per_call_usd must be a positive number \u2264 100");await O(`/api/v1/instances/${n}/cost-per-call`,{method:"PUT",body:JSON.stringify({cost_per_call_usd:e})});const a={"0.02":"claude-opus-4.8","0.015":"gpt-5.5","0.009":"claude-sonnet-4.6","0.002":"gpt-5.5-mini","0.001":"claude-haiku-4.5"},t=a[e.toString()]?` (${a[e.toString()]})`:"";return[`\u2705 **Cost per call updated** \u2014 $${e.toFixed(4)}${t}`,"",`ROI savings in \`cache_stats\` will now use $${e.toFixed(4)} per avoided LLM call.`,"Run `cache_stats` to see your updated savings estimate."].join(`
+`)}default:return null}}export{de as CACHE_TOOL_NAMES,he as handleCacheTool};