prism-mcp-server 8.0.2 → 9.0.4

package/dist/utils/embeddingApi.js

@@ -1,104 +0,0 @@
-/**
- * Embedding Generation Utility (v0.5.0 — Model Migration)
- *
- * ═══════════════════════════════════════════════════════════════════
- * REVIEWER NOTE: This module wraps Google's gemini-embedding-001 model
- * to generate 768-dimensional vector embeddings for text.
- *
- * MIGRATION (2026-03): text-embedding-004 was deprecated Jan 14, 2026.
- * Replaced with gemini-embedding-001 (GA on v1 API). The new model
- * supports Matryoshka Representation Learning (MRL) for flexible
- * output dimensions (768, 1536, 3072). We use 768 for compatibility
- * with existing pgvector columns.
- *
- * USAGE — Called in two places:
- *   1. sessionSaveLedgerHandler — embeds summary+decisions at save time
- *      (fire-and-forget, non-blocking)
- *   2. sessionSearchMemoryHandler — embeds the user's search query
- *      to find semantically similar past sessions
- *
- * WHY GEMINI: We already have @google/generative-ai as a dependency
- * and GOOGLE_API_KEY configured for the research paper analysis tool.
- * Using a separate embedding service (OpenAI, Cohere) would add
- * another API key dependency and increase configuration complexity.
- *
- * COST: Gemini's gemini-embedding-001 is free tier for <1500 req/min.
- * At typical usage (~10-50 ledger saves/day), we'll never approach
- * this limit.
- *
- * TRUNCATION GUARD: gemini-embedding-001 supports up to 2048 tokens
- * per input. We implement a hard character limit (default 8000 chars)
- * to guarantee the API call never crashes. This is applied before
- * sending to the API, not after.
- * ═══════════════════════════════════════════════════════════════════
- */
-import { GoogleGenerativeAI, TaskType } from "@google/generative-ai";
-import { GOOGLE_API_KEY } from "../config.js";
-import { debugLog } from "./logger.js";
-// ─── Constants ────────────────────────────────────────────────
-// REVIEWER NOTE: Maximum characters to send to the embedding API.
-// gemini-embedding-001 supports up to 2048 tokens. At ~4 chars/token,
-// 8000 chars is a safe ceiling. Truncation is silent and non-fatal —
-// the embedding still captures the semantic meaning of the leading
-// content, which is more than enough for similarity search.
-const MAX_EMBEDDING_CHARS = 8000;
-// ─── Embedding Client ─────────────────────────────────────────
-/**
- * Generates a 768-dimensional embedding vector for the given text.
- *
- * @param text - The text to embed (summary + decisions, search query, etc.)
- * @returns Array of 768 floating-point numbers representing the text's
- *          semantic meaning in vector space.
- * @throws Error if GOOGLE_API_KEY is not configured or API call fails.
- *
- * REVIEWER NOTE: The truncation happens BEFORE the API call, not after.
- * If the text is longer than MAX_EMBEDDING_CHARS, we silently truncate
- * and log a warning to stderr. This prevents 400 Bad Request errors
- * from the Gemini API without blocking the caller.
- */
-export async function generateEmbedding(text) {
-    if (!GOOGLE_API_KEY) {
-        throw new Error("Cannot generate embeddings: GOOGLE_API_KEY is not configured. " +
-            "Set this environment variable to enable semantic search.");
-    }
-    // Truncation guard — prevent exceeding API token limits
-    // REVIEWER NOTE (v1.5.0 fix): JavaScript's substring() counts UTF-16
-    // code units. If the cut point lands in the middle of a surrogate pair
-    // (e.g., emoji 🚀 or complex CJK characters), the result contains an
-    // invalid trailing byte (\uFFFD) that some APIs reject with 400.
-    // Fix: truncate at the last word boundary before the limit.
-    let inputText = text;
-    if (inputText.length > MAX_EMBEDDING_CHARS) {
-        debugLog(`[embedding] Input text truncated from ${inputText.length} to ~${MAX_EMBEDDING_CHARS} chars (word-safe)`);
-        inputText = inputText.substring(0, MAX_EMBEDDING_CHARS);
-        // Snap back to the last space to avoid splitting a word or surrogate pair
-        const lastSpace = inputText.lastIndexOf(' ');
-        if (lastSpace > 0) {
-            inputText = inputText.substring(0, lastSpace);
-        }
-    }
-    // Skip empty or whitespace-only text
-    if (!inputText.trim()) {
-        throw new Error("Cannot generate embedding for empty text");
-    }
-    const genAI = new GoogleGenerativeAI(GOOGLE_API_KEY);
-    const model = genAI.getGenerativeModel({ model: "gemini-embedding-001" }, { apiVersion: "v1beta" } // gemini-embedding-001 requires v1beta
-    );
-    debugLog(`[embedding] Generating 768-dim embedding for ${inputText.length} chars`);
-    const request = {
-        content: {
-            role: "user",
-            parts: [{ text: inputText }],
-        },
-        taskType: TaskType.SEMANTIC_SIMILARITY,
-        // SDK runtime supports this for gemini-embedding-001 even when older
-        // type defs may lag; keep cast localized at request boundary.
-        ...{ outputDimensionality: 768 },
-    };
-    const result = await model.embedContent(request);
-    const values = result.embedding.values;
-    if (!Array.isArray(values) || values.length !== 768) {
-        throw new Error(`Embedding dimension mismatch: expected 768, got ${values?.length ?? 'unknown'}`);
-    }
-    return values;
-}

package/dist/utils/googleAi.js

@@ -1,88 +0,0 @@
-/**
- * Google Gemini AI Client
- *
- * This module integrates with Google's Gemini AI models for research
- * paper analysis. It uses the @google/generative-ai SDK (Google AI Studio).
- *
- * Current model: gemini-2.0-flash (fast, high-quality, good for long documents)
- *
- * The main function (analyzePaperWithGemini) takes a paper's full text and
- * generates a detailed analysis based on the requested type:
- *   - "summary"           → research question, methodology, findings, conclusions
- *   - "critique"          → methodology assessment, validity, limitations
- *   - "literature review" → how it fits in the broader research landscape
- *   - "key findings"      → most significant results and implications
- *   - "comprehensive"     → all of the above combined (default)
- *
- * Requires: GOOGLE_API_KEY environment variable
- *
- * Note: This module also exports an MCP client factory (createMcpClient)
- * which can be used for testing or inter-server communication.
- */
-import { GoogleGenerativeAI } from "@google/generative-ai";
-import { Readable } from "stream";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-export const googleGenAi = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
-export function bufferToStream(buffer) {
-    const stream = new Readable();
-    stream.push(buffer);
-    stream.push(null); // Signal the end of the stream
-    return stream;
-}
-/**
- * Creates an MCP client connected to the Brave Search server
- */
-export async function createMcpClient() {
-    const transport = new StdioClientTransport({
-        command: "node",
-        args: ["index.js"], // Server entry point
-    });
-    const client = new Client({ name: "gemini-mcp-client", version: "1.0.0" });
-    await client.connect(transport);
-    return { client, transport };
-}
-/**
- * Analyzes research paper content using Google's Gemini-2.0-flash model
- * @param paperContent - The text content of the research paper
- * @param analysisType - The type of analysis to perform (summary, critique, etc.)
- * @param additionalContext - Any additional context or specific questions
- * @returns Detailed analysis of the research paper
- */
-export async function analyzePaperWithGemini(paperContent, analysisType, additionalContext) {
-    try {
-        // Initialize the Gemini Pro model
-        const model = googleGenAi.getGenerativeModel({ model: "gemini-2.0-flash" });
-        // Create the prompt based on analysis type
-        let prompt = `I need you to perform a detailed ${analysisType} analysis of the following research paper.\n\n`;
-        if (additionalContext) {
-            prompt += `Additional context: ${additionalContext}\n\n`;
-        }
-        prompt += `Research paper content:\n${paperContent}\n\n`;
-        switch (analysisType.toLowerCase()) {
-            case "summary":
-                prompt += "Provide a comprehensive summary including the research question, methodology, key findings, and conclusions.";
-                break;
-            case "critique":
-                prompt += "Provide a critical evaluation of the research methodology, validity of findings, limitations, and suggestions for improvement.";
-                break;
-            case "literature review":
-                prompt += "Analyze how this paper fits into the broader research landscape, identifying key related works and research gaps.";
-                break;
-            case "key findings":
-                prompt += "Extract and explain the most significant findings and their implications.";
-                break;
-            default:
-                prompt += "Perform a comprehensive analysis including summary, methodology assessment, key findings, limitations, and significance.";
-        }
-        // Generate content using Gemini
-        const result = await model.generateContent(prompt);
-        const response = await result.response;
-        const text = response.text();
-        return text;
-    }
-    catch (error) {
-        console.error("Error analyzing paper with Gemini:", error);
-        throw new Error(`Failed to analyze paper: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/utils/testUniversalImporter.js

@@ -1,10 +0,0 @@
-import { importHistory } from './universalImporter.js';
-async function test() {
-    const claudePath = '/tmp/sample_claude_history.jsonl';
-    const geminiPath = '/tmp/sample_gemini_history.json';
-    console.log('--- TEST 1: Claude JSONL (Dry Run) ---');
-    await importHistory(claudePath, { format: 'claude-jsonl', dryRun: true, verbose: true });
-    console.log('\n--- TEST 2: Gemini JSON (Dry Run) ---');
-    await importHistory(geminiPath, { format: 'gemini-json', dryRun: true, verbose: true, projectId: 'gemini-test' });
-}
-test().catch(console.error);

package/dist/verification/renameDetector.js

@@ -1,170 +0,0 @@
-/**
- * Rename Detection Heuristic Engine
- *
- * Isolated module that detects probable test assertion renames by computing
- * similarity scores between removed and added tests. This module is ONLY
- * invoked when rename detection is explicitly enabled via --rename-detection
- * flag or PRISM_RENAME_DETECTION=true env var.
- *
- * When this module is NOT invoked, the strict-by-ID deterministic behavior
- * of v7.3.2 is preserved byte-for-byte.
- *
- * Algorithm: Greedy bipartite matching on composite similarity scores.
- * - Field overlap via Jaccard coefficient over non-ID field values
- * - Description similarity via normalized Levenshtein distance
- * - Greedy highest-score-first, one-to-one matching (no test matched twice)
- *
- * @module renameDetector
- */
-// ─── Constants ────────────────────────────────────────────────────────────────
-/** Minimum allowed threshold (too low = excessive false positives) */
-export const MIN_THRESHOLD = 0.50;
-/** Maximum allowed threshold (too high = nothing ever matches) */
-export const MAX_THRESHOLD = 0.95;
-/** Default similarity threshold when not specified */
-export const DEFAULT_THRESHOLD = 0.70;
-// ─── Similarity Functions ─────────────────────────────────────────────────────
-/**
- * Compute normalized Levenshtein distance between two strings.
- * Returns 0.0 (completely different) to 1.0 (identical).
- */
-export function levenshteinSimilarity(a, b) {
-    if (a === b)
-        return 1.0;
-    if (a.length === 0 || b.length === 0)
-        return 0.0;
-    const maxLen = Math.max(a.length, b.length);
-    // Wagner-Fischer algorithm for edit distance
-    const prev = new Array(b.length + 1);
-    const curr = new Array(b.length + 1);
-    for (let j = 0; j <= b.length; j++)
-        prev[j] = j;
-    for (let i = 1; i <= a.length; i++) {
-        curr[0] = i;
-        for (let j = 1; j <= b.length; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            curr[j] = Math.min(curr[j - 1] + 1, // insertion
-            prev[j] + 1, // deletion
-            prev[j - 1] + cost);
-        }
-        // Swap rows
-        for (let j = 0; j <= b.length; j++) {
-            prev[j] = curr[j];
-        }
-    }
-    const distance = prev[b.length];
-    return 1.0 - distance / maxLen;
-}
-/**
- * Compute Jaccard similarity coefficient over the non-ID field values
- * of two TestAssertion objects.
- * Returns 0.0 (no overlap) to 1.0 (identical field values).
- */
-export function fieldJaccardSimilarity(a, b) {
-    const keysA = Object.keys(a).filter(k => k !== 'id');
-    const keysB = Object.keys(b).filter(k => k !== 'id');
-    const allKeys = new Set([...keysA, ...keysB]);
-    if (allKeys.size === 0)
-        return 1.0; // Both empty — trivially identical
-    let matches = 0;
-    for (const key of allKeys) {
-        const valA = JSON.stringify(a[key]);
-        const valB = JSON.stringify(b[key]);
-        if (valA === valB)
-            matches++;
-    }
-    return matches / allKeys.size;
-}
-/**
- * Compute composite similarity between two TestAssertions.
- * Weights: 40% Jaccard field overlap + 60% Levenshtein on description.
- *
- * The heavier description weight reflects the observation that operators
- * typically rename tests when restructuring but preserve the intent —
- * the description carries the most semantic signal.
- */
-export function compositeSimilarity(removed, added) {
-    const jaccard = fieldJaccardSimilarity(removed, added);
-    const descSim = levenshteinSimilarity(removed.description || '', added.description || '');
-    return 0.4 * jaccard + 0.6 * descSim;
-}
-/**
- * Compute field-level changed_keys between two TestAssertions (excluding id).
- */
-function computeChangedKeys(removed, added) {
-    const allKeys = new Set([
-        ...Object.keys(removed).filter(k => k !== 'id'),
-        ...Object.keys(added).filter(k => k !== 'id'),
-    ]);
-    const changed = [];
-    for (const key of allKeys) {
-        if (JSON.stringify(removed[key]) !== JSON.stringify(added[key])) {
-            changed.push(key);
-        }
-    }
-    changed.sort();
-    return changed;
-}
-// ─── Core Detection ───────────────────────────────────────────────────────────
-/**
- * Clamp and validate the threshold value.
- */
-export function clampThreshold(threshold) {
-    return Math.max(MIN_THRESHOLD, Math.min(MAX_THRESHOLD, threshold));
-}
-/**
- * Detect probable renames between removed and added test assertion sets.
- *
- * Uses greedy bipartite matching: compute all pairwise similarity scores,
- * sort descending, and greedily assign one-to-one matches above threshold.
- * This is O(n*m) where n=|removed|, m=|added| — acceptable for test suites
- * which are typically <100 assertions.
- *
- * @param added   Tests present locally but not in stored harness
- * @param removed Tests present in stored harness but not locally
- * @param threshold Minimum similarity to consider a rename (0.50-0.95)
- * @returns Detected renames and residual unmatched tests
- */
-export function detectRenames(added, removed, threshold = DEFAULT_THRESHOLD) {
-    const effectiveThreshold = clampThreshold(threshold);
-    // Edge case: nothing to match
-    if (added.length === 0 || removed.length === 0) {
-        return { renamed: [], residualAdded: [...added], residualRemoved: [...removed] };
-    }
-    const pairs = [];
-    for (let ri = 0; ri < removed.length; ri++) {
-        for (let ai = 0; ai < added.length; ai++) {
-            const sim = compositeSimilarity(removed[ri], added[ai]);
-            if (sim >= effectiveThreshold) {
-                pairs.push({ removedIdx: ri, addedIdx: ai, similarity: sim });
-            }
-        }
-    }
-    // Step 2: Sort descending by similarity (greedy — highest first)
-    pairs.sort((a, b) => b.similarity - a.similarity);
-    // Step 3: Greedy one-to-one matching
-    const matchedRemoved = new Set();
-    const matchedAdded = new Set();
-    const renamed = [];
-    for (const pair of pairs) {
-        if (matchedRemoved.has(pair.removedIdx) || matchedAdded.has(pair.addedIdx)) {
-            continue; // Already matched — skip
-        }
-        matchedRemoved.add(pair.removedIdx);
-        matchedAdded.add(pair.addedIdx);
-        const removedTest = removed[pair.removedIdx];
-        const addedTest = added[pair.addedIdx];
-        renamed.push({
-            removed: removedTest,
-            added: addedTest,
-            similarity: Math.round(pair.similarity * 1000) / 1000, // 3 decimal places
-            changed_keys: computeChangedKeys(removedTest, addedTest),
-        });
-    }
-    // Step 4: Build residuals — unmatched tests stay in added/removed
-    const residualAdded = added.filter((_, i) => !matchedAdded.has(i));
-    const residualRemoved = removed.filter((_, i) => !matchedRemoved.has(i));
-    // Sort renamed by old_id for deterministic output within the heuristic domain
-    renamed.sort((a, b) => a.removed.id.localeCompare(b.removed.id));
-    return { renamed, residualAdded, residualRemoved };
-}