@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.0

package/dist/server/mcp-http.js

@@ -1,95 +0,0 @@
-// code-mapper/src/server/mcp-http.ts
-/** @file mcp-http.ts
- *  @description Mounts Code Mapper MCP server on Express using StreamableHTTP transport
- *  Each client gets a stateful session; LocalBackend is shared (thread-safe)
- *  Sessions are evicted on close or after idle timeout */
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { createMCPServer } from '../mcp/server.js';
-import { randomUUID } from 'crypto';
-/** Idle sessions are evicted after 30 minutes */
-const SESSION_TTL_MS = 30 * 60 * 1000;
-/** Cleanup sweep runs every 5 minutes */
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
-export function mountMCPEndpoints(app, backend) {
-    const sessions = new Map();
-    // Periodic cleanup of idle sessions
-    const cleanupTimer = setInterval(() => {
-        const now = Date.now();
-        for (const [id, session] of sessions) {
-            if (now - session.lastActivity > SESSION_TTL_MS) {
-                try {
-                    session.server.close();
-                }
-                catch { }
-                sessions.delete(id);
-            }
-        }
-    }, CLEANUP_INTERVAL_MS);
-    if (cleanupTimer && typeof cleanupTimer === 'object' && 'unref' in cleanupTimer) {
-        cleanupTimer.unref();
-    }
-    const handleMcpRequest = async (req, res) => {
-        const sessionId = req.headers['mcp-session-id'];
-        if (sessionId && sessions.has(sessionId)) {
-            // Existing session — delegate to its transport
-            const session = sessions.get(sessionId);
-            session.lastActivity = Date.now();
-            await session.transport.handleRequest(req, res, req.body);
-        }
-        else if (sessionId) {
-            // Unknown/expired session ID (per MCP spec, tell client to re-initialize)
-            res.status(404).json({
-                jsonrpc: '2.0',
-                error: { code: -32001, message: 'Session not found. Re-initialize.' },
-                id: null,
-            });
-        }
-        else if (req.method === 'POST') {
-            // No session ID — new client initializing
-            const transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-            });
-            const server = createMCPServer(backend);
-            await server.connect(transport);
-            await transport.handleRequest(req, res, req.body);
-            if (transport.sessionId) {
-                sessions.set(transport.sessionId, { server, transport, lastActivity: Date.now() });
-                transport.onclose = () => {
-                    sessions.delete(transport.sessionId);
-                };
-            }
-        }
-        else {
-            res.status(400).json({
-                jsonrpc: '2.0',
-                error: { code: -32000, message: 'No valid session. Send a POST to initialize.' },
-                id: null,
-            });
-        }
-    };
-    app.all('/api/mcp', (req, res) => {
-        void handleMcpRequest(req, res).catch((err) => {
-            console.error('MCP HTTP request failed:', err);
-            if (res.headersSent)
-                return;
-            res.status(500).json({
-                jsonrpc: '2.0',
-                error: { code: -32000, message: 'Internal MCP server error' },
-                id: null,
-            });
-        });
-    });
-    const cleanup = async () => {
-        clearInterval(cleanupTimer);
-        const closers = [...sessions.values()].map(async (session) => {
-            try {
-                await Promise.resolve(session.server.close());
-            }
-            catch { }
-        });
-        sessions.clear();
-        await Promise.allSettled(closers);
-    };
-    console.log('MCP HTTP endpoints mounted at /api/mcp');
-    return cleanup;
-}

package/models/mlx-embedder.py

@@ -1,185 +0,0 @@
-#!/usr/bin/env python3
-"""
-MLX-accelerated code embedder for Apple Silicon.
-
-Runs as a persistent subprocess — reads JSON batches from stdin,
-outputs embeddings to stdout. Node.js parent communicates via IPC.
-
-Protocol:
-  Input (one JSON per line):  {"texts": [...], "task": "nl2code", "type": "query"|"passage", "dims": 256}
-  Output (one JSON per line): {"embeddings": [[...], [...]], "ms": 42}
-
-  Special commands:
-  {"cmd": "ping"}  -> {"status": "ready", "model": "jina-code-1.5b", "device": "gpu"}
-  {"cmd": "quit"}  -> exits
-
-Optimizations:
-  - Length-tiered batching: short texts in large batches, long texts in small batches
-  - Sorted by length within tiers to minimize padding waste
-  - Results returned in original input order
-"""
-
-import sys
-import os
-import json
-import time
-
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-try:
-    import mlx.core as mx
-    from tokenizers import Tokenizer
-except ImportError:
-    print(json.dumps({"error": "MLX not installed. Run: pip3 install mlx tokenizers huggingface_hub"}), flush=True)
-    sys.exit(1)
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-MODEL_DIR = os.path.join(SCRIPT_DIR, "jina-code-1.5b-mlx")
-HF_REPO = "jinaai/jina-code-embeddings-1.5b-mlx"
-
-def ensure_model():
-    """Download the model if not present."""
-    safetensors = os.path.join(MODEL_DIR, "model.safetensors")
-    if os.path.exists(safetensors):
-        return
-
-    print(json.dumps({"status": "downloading", "model": HF_REPO}), flush=True)
-    try:
-        from huggingface_hub import snapshot_download
-        snapshot_download(HF_REPO, local_dir=MODEL_DIR)
-    except Exception as e:
-        print(json.dumps({"error": f"Model download failed: {e}"}), flush=True)
-        sys.exit(1)
-
-# Length-tiered batch sizes — shorter texts can batch more efficiently
-# Char thresholds and max batch sizes per tier
-TIERS = [
-    (500,   128),  # very short (signatures, interfaces)
-    (2000,  64),   # short (small functions)
-    (8000,  24),   # medium (typical functions)
-    (32000, 8),    # long (large functions, classes)
-    (999999, 4),   # very long (entire files)
-]
-
-def load_model():
-    sys.path.insert(0, MODEL_DIR)
-    from model import JinaCodeEmbeddingModel
-
-    with open(os.path.join(MODEL_DIR, "config.json")) as f:
-        config = json.load(f)
-
-    model = JinaCodeEmbeddingModel(config)
-    weights = mx.load(os.path.join(MODEL_DIR, "model.safetensors"))
-    model.load_weights(list(weights.items()))
-    mx.eval(model.parameters())
-
-    tokenizer = Tokenizer.from_file(os.path.join(MODEL_DIR, "tokenizer.json"))
-
-    return model, tokenizer
-
-
-def get_batch_size_for_length(char_len):
-    for threshold, batch_size in TIERS:
-        if char_len <= threshold:
-            return batch_size
-    return 4
-
-
-def embed_tiered(model, tokenizer, texts, task="nl2code", prompt_type="passage", truncate_dim=256):
-    """Embed texts with length-tiered batching for optimal throughput.
-    Returns embeddings in the ORIGINAL input order."""
-    if not texts:
-        return []
-
-    # Create index-text pairs, sort by length
-    indexed = sorted(enumerate(texts), key=lambda x: len(x[1]))
-
-    # Process in length-tiered batches
-    all_embeddings = [None] * len(texts)
-    i = 0
-
-    while i < len(indexed):
-        # Determine batch size based on the length of the longest text in this batch
-        char_len = len(indexed[min(i + 1, len(indexed) - 1)][1])  # peek at a representative
-        batch_size = get_batch_size_for_length(char_len)
-
-        batch_indices = []
-        batch_texts = []
-
-        # Fill batch with texts of similar length
-        while len(batch_texts) < batch_size and i < len(indexed):
-            orig_idx, text = indexed[i]
-            batch_indices.append(orig_idx)
-            batch_texts.append(text)
-            i += 1
-
-        # Run inference
-        embeddings = model.encode(
-            batch_texts,
-            tokenizer,
-            task=task,
-            prompt_type=prompt_type,
-            truncate_dim=truncate_dim,
-        )
-        mx.eval(embeddings)
-
-        # Store results at original indices
-        emb_list = embeddings.tolist()
-        for j, orig_idx in enumerate(batch_indices):
-            all_embeddings[orig_idx] = emb_list[j]
-
-    return all_embeddings
-
-
-def main():
-    ensure_model()
-    t0 = time.time()
-    model, tokenizer = load_model()
-    load_ms = int((time.time() - t0) * 1000)
-
-    print(json.dumps({
-        "status": "ready",
-        "model": "jina-code-1.5b-mlx",
-        "device": str(mx.default_device()),
-        "load_ms": load_ms,
-    }), flush=True)
-
-    for line in sys.stdin:
-        line = line.strip()
-        if not line:
-            continue
-
-        try:
-            req = json.loads(line)
-        except json.JSONDecodeError:
-            print(json.dumps({"error": "Invalid JSON"}), flush=True)
-            continue
-
-        if "cmd" in req:
-            if req["cmd"] == "ping":
-                print(json.dumps({"status": "ready"}), flush=True)
-            elif req["cmd"] == "quit":
-                break
-            continue
-
-        texts = req.get("texts", [])
-        task = req.get("task", "nl2code")
-        prompt_type = req.get("type", "passage")
-        dims = req.get("dims", 256)
-
-        t0 = time.time()
-        try:
-            embeddings = embed_tiered(model, tokenizer, texts, task, prompt_type, dims)
-            elapsed_ms = int((time.time() - t0) * 1000)
-
-            print(json.dumps({
-                "embeddings": embeddings,
-                "count": len(embeddings),
-                "dims": dims,
-                "ms": elapsed_ms,
-            }), flush=True)
-        except Exception as e:
-            print(json.dumps({"error": str(e)}), flush=True)
-
-if __name__ == "__main__":
-    main()