fmea-api-mcp-server 1.1.13 → 1.1.15

package/dist/index.js

@@ -28,7 +28,7 @@ class ApiDocsServer {
     constructor() {
         this.server = new Server({
             name: "api-docs-mcp",
-            version: "1.1.13",
+            version: "1.1.15",
         }, {
             capabilities: {
                 resources: {},

package/dist/intents.js

@@ -13,7 +13,7 @@ export const ACTION_KEYWORDS = {
     'MONITOR': ['monitor', 'track', 'audit', 'inspect', 'history', 'logs', 'usage', 'metrics', 'stats'],
     // CRUD
     'create': ['create', 'add', 'new', 'make', 'generate', 'register'],
-    'update': ['update', 'edit', 'change', 'modify', 'save', 'set', 'reset', 'password', 'refresh'],
+    'update': ['update', 'edit', 'change', 'modify', 'save', 'set', 'reset', 'password', 'refresh', 'approve', 'reject'],
     'delete': ['delete', 'remove', 'drop', 'erase'],
     'list': ['list', 'get', 'show', 'fetch', 'all', 'view', 'files', 'status', 'check'],
 };

package/dist/services/search/OramaSearchService.js

@@ -1,9 +1,11 @@
 import { create, load, search } from '@orama/orama';
 import { pipeline } from '@xenova/transformers';
 import fs from 'fs/promises';
+import path from 'path';
 import { paginateResults, DEFAULT_PAGE_SIZE } from '../../utils/search-helper.js';
 import { endpointSchema } from './schema.js';
 import { RESOURCE_ALIASES } from '../../synonyms.js';
+import { getSynonyms } from '../../synonyms.js';
 import { ACTION_KEYWORDS, ACTION_PRIORITY } from '../../intents.js';
 import { ScoreCalculator } from '../../utils/ScoreCalculator.js';
 export class OramaSearchService {
@@ -14,6 +16,7 @@ export class OramaSearchService {
     knownResources = ['project', 'block-diagram', 'worksheet', 'failure-mode', 'action', 'block-node', 'division', 'user', 'document', 'file', 'api-key', 'fault-tree', 'oauth'];
     debugMode;
     scoreCalculator;
+    lookup = new Map();
     constructor(indexPath, debugMode = false) {
         this.indexPath = indexPath;
         this.debugMode = debugMode;
@@ -35,14 +38,25 @@ export class OramaSearchService {
             });
             // Load data into the DB instance
             await load(this.db, JSON.parse(data));
-            // Initialize model lazily or here. Here is better to fail fast.
+            // Load endpoint-lookup.json
+            const lookupPath = path.join(path.dirname(this.indexPath), 'endpoint-lookup.json');
+            try {
+                const lookupData = await fs.readFile(lookupPath, 'utf-8');
+                const lookupObj = JSON.parse(lookupData);
+                for (const [key, value] of Object.entries(lookupObj)) {
+                    this.lookup.set(key, value);
+                }
+                console.error(`✅ OramaSearchService: Loaded ${this.lookup.size} endpoint lookups.`);
+            }
+            catch (lookupError) {
+                console.error('⚠️ OramaSearchService: endpoint-lookup.json not found, falling back to index-only mode.');
+            }
             // Initialize model lazily or here. Here is better to fail fast.
             this.extractor = await pipeline('feature-extraction', 'Xenova/bge-small-en-v1.5');
             console.error('✅ OramaSearchService: Index loaded and model ready.');
         }
         catch (error) {
             console.error('❌ OramaSearchService initialization failed:', error);
-            // Fallback strategy could be implemented here or handled by the caller
         }
     }
     async search(query, filterMethod, filterVersion, page = 1, explicitPath) {
@@ -51,13 +65,10 @@ export class OramaSearchService {
             return { results: [], meta: { total: 0, page, totalPages: 0 }, warning: 'Search service not initialized' };
         }
         if (!query || query.trim() === '') {
-            // Without query, we could verify behavior. Usually empty query means "list all" or "list categories"
-            // But per interface, search() expects a query string.
             return { results: [], meta: { total: 0, page, totalPages: 0 } };
         }
         try {
             // 1. Explicit Path Search (Exact/Contains) - High Priority
-            // [R16] Path Mode Detection: If query looks like a path, treat as explicit path search
             const isPathQuery = query.startsWith('/') || query.startsWith('api/');
             if (explicitPath || isPathQuery) {
                 const targetPath = explicitPath || query;
@@ -72,11 +83,12 @@ export class OramaSearchService {
                 // Sort by path length to prioritize exact match (shortest) over children
                 hits.sort((a, b) => a.document.path.length - b.document.path.length);
                 const results = hits.map((hit) => {
-                    const sourceData = JSON.parse(hit.document.jsonBlob);
+                    const id = hit.document.id;
+                    const sourceData = this.lookup.get(id) || {};
                     const result = {
                         path: hit.document.path,
                         method: hit.document.method,
-                        summary: hit.document.summary,
+                        summary: sourceData.summary || '',
                         description: hit.document.description,
                         score: 1.0, // Forced high score for explicit match
                     };
@@ -100,14 +112,27 @@ export class OramaSearchService {
                 console.error(`[Orama] Detected Action: ${intent.action}`);
             if (intent.resource)
                 console.error(`[Orama] Detected Resource: ${intent.resource}`);
+            // Query-time synonym expansion (targeted, not exhaustive)
             let expandedQuery = safeQuery;
+            // Resource name expansion from intent detection
             if (intent.resource) {
                 const resourceNameStr = intent.resource.replace(/-/g, ' ');
                 if (!expandedQuery.toLowerCase().includes(resourceNameStr)) {
                     expandedQuery += ` ${resourceNameStr}`;
-                    console.error(`[Orama] Expanded Query: "${expandedQuery}"`);
                 }
             }
+            // Limited token-level synonym expansion:
+            // Add only direct synonyms (max 3 per token) to preserve BM25 signal
+            const tokens = safeQuery.toLowerCase().split(/\s+/).filter(t => t.length >= 3);
+            const extraSynonyms = [];
+            for (const token of tokens) {
+                const syns = getSynonyms(token).filter(s => s !== token && !tokens.includes(s));
+                extraSynonyms.push(...syns.slice(0, 3));
+            }
+            if (extraSynonyms.length > 0) {
+                expandedQuery += ' ' + extraSynonyms.join(' ');
+            }
+            console.error(`[Orama] Expanded Query: "${expandedQuery}"`);
             const output = await this.extractor(safeQuery, { pooling: 'mean', normalize: true });
             const embedding = Array.from(output.data);
             // 3. Build Where Clauses
@@ -116,37 +141,30 @@ export class OramaSearchService {
                 where.method = filterMethod;
             if (filterVersion)
                 where.version = filterVersion;
-            // 4. Search
+            // 4. Search — description-centric with path support
             const searchResult = await search(this.db, {
                 term: expandedQuery,
-                tolerance: 2, // [Fix] Enable fuzzy matching for typos (e.g. "creaet projetc")
-                // [Fix] Explicitly search in keywords
-                properties: ['path', 'summary', 'description', 'keywords'],
+                tolerance: 2,
+                properties: ['description', 'path'],
+                boost: {
+                    description: 5.0,
+                    path: 10.0
+                },
                 vector: {
                     value: embedding,
                     property: 'embedding'
                 },
                 mode: 'hybrid',
-                similarity: 0, // [Fix] Disable vector threshold completely to depend on gating logic
-                boost: {
-                    path: 15.0,
-                    keywords: 30.0,
-                    summary: 15.0,
-                    description: 5.0
-                },
+                similarity: 0,
                 where,
-                limit: 1000, // [Fix R15] Fetch more candidates to ensure re-ranking targets are included (low IDF fix)
+                limit: 1000,
                 offset: 0
             });
-            // (Debug removed)
             // 5. Threshold Filtering & Mapping with Structural Analysis
             const results = [];
-            // Intent detection moved up.
             for (const hit of searchResult.hits) {
                 let score = hit.score;
-                // (Debug removed)
                 // Structural Metadata from Index
-                // Note: These fields are only available if the index was built with the new schema & logic
                 const docResource = hit.document.resourceType || 'unknown';
                 const docAction = hit.document.actionType || 'other';
                 // A. & B. Intent Scoring via ScoreCalculator
@@ -155,28 +173,7 @@ export class OramaSearchService {
                     actionType: docAction,
                     score: score
                 });
-                // Legacy Logic Preservation (optional, maybe reduce weights)
-                // ... (Existing explicit path logic is skipped here as it's separate block)
-                // [Final Plan] Hybrid Gating (Gray Zone Filtering)
-                // Check if we should KEEP or DROP based on score brackets
-                // [Final Plan] Hybrid Gating (Gray Zone Filtering)
-                // Check if we should KEEP or DROP based on score brackets
-                // Normalized brackets:
-                // HIGH_PASS = 0.55 / 600 * 600 ??? No, wait. 
-                // Old scores were raw. New scores are normalized (0.0 - 1.0).
-                // Max score ~600. 
-                // Old HIGH_PASS = 0.55 (Wait, 0.55 was for normalized?? No, previously it wasn't normalized)
-                // Actually, looking at previous code, Orama scores were ~10-15 base. 
-                // 0.55 seems VERY low for HIGH_PASS if boosts are +500.
-                // It seems previous threshold logic might have been based on raw Orama scores BEFORE boosts?
-                // Let's re-read: "score = hit.score" then boosts added.
-                // But "score > 10.0" check suggests intents were boosting > 10.
-                // With normalization:
-                // High Pass: Strong intent match (~500+) -> ~0.83
-                // Medium Pass: Partial match (~50+) -> ~0.1
-                // Base score (~15) -> ~0.025
                 // [Final Plan] Intent-Based Thresholding
-                // Goal: Remove noise (Action-only matches) when Intent is clear.
                 let THRESHOLD_SCORE = 0.05; // Default (Loose)
                 if (intent.resource) {
                     THRESHOLD_SCORE = 0.2;
@@ -185,39 +182,21 @@ export class OramaSearchService {
                     THRESHOLD_SCORE = 0.08;
                 }
                 else {
-                    // [Fix] Low threshold for No Intent (Fuzzy/Typo handling)
-                    // Unboosted vector matches (0.8) have normalized scores ~0.0013.
-                    // 0.005 is too high. 0.001 allows strong vector matches.
-                    // [Round 18] Increased to 0.01 to filter garbage like 'UPPERCASE QUERY' or 'very long...'
-                    // Real keyword matches (boost=30) will be > 0.05.
                     THRESHOLD_SCORE = 0.01;
                 }
                 let keep = false;
-                // [Fix] Short queries (e.g. "x") can have high IDF/score due to noise. 
-                // Force them to pass strict token matching.
                 const isShortQuery = safeQuery.length <= 2;
                 if (score >= THRESHOLD_SCORE && !isShortQuery) {
-                    // Passed Threshold -> Keep
                     keep = true;
                 }
                 else if (isShortQuery) {
-                    // Short Query Logic (same as before)
-                    const keywordsBag = (hit.document.keywords || '').toLowerCase();
+                    // Short Query Logic: check description for token match
+                    const descBag = (hit.document.description || '').toLowerCase();
                     const inputTokens = safeQuery.toLowerCase().split(/\s+/).filter(t => t.length > 0);
                     const queryTokens = new Set(inputTokens);
                     if (queryTokens.size > 0) {
-                        // ... Fuzzy logic reuse or simplified check ...
-                        // For simplicity in this replacement, let's just check direct inclusion for short queries to avoid bloat
-                        // Or keep existing fuzzy logic if possible.
-                        // Let's assume the previous fuzzy logic block was good. I will try to preserve it or simplify.
-                        // Given tool limitations, I will rewrite the essential fuzzy check here.
-                        const docTokens = new Set(keywordsBag.split(/\s+/));
-                        const match = Array.from(queryTokens).some(token => {
-                            if (docTokens.has(token))
-                                return true;
-                            // Minimal fuzzy for 3-char fallback?
-                            return false;
-                        });
+                        const docTokens = new Set(descBag.split(/\s+/));
+                        const match = Array.from(queryTokens).some(token => docTokens.has(token));
                         if (match)
                             keep = true;
                     }
@@ -227,11 +206,12 @@ export class OramaSearchService {
                 }
                 if (!keep)
                     continue;
-                const sourceData = JSON.parse(hit.document.jsonBlob);
+                const id = hit.document.id;
+                const sourceData = this.lookup.get(id) || {};
                 const result = {
                     path: hit.document.path,
                     method: hit.document.method,
-                    summary: hit.document.summary,
+                    summary: sourceData.summary || '',
                     description: hit.document.description,
                     score: score,
                     resourceType: docResource,
@@ -240,20 +220,14 @@ export class OramaSearchService {
                     tags: sourceData.tags,
                     warning: sourceData['x-dependency-warning'] || sourceData.warning,
                 };
-                // Include score in debug mode (already included above, but for consistency)
-                if (!this.debugMode) {
-                    // In non-debug mode, exclude heavy fields
-                    // (already excluded by not spreading sourceData)
-                }
                 results.push(result);
             }
             // Re-sort because scores changed
             results.sort((a, b) => (b.score || 0) - (a.score || 0));
             // 6. Pagination (Slicing)
-            const filteredTotal = results.length; // True count of matching items
+            const filteredTotal = results.length;
             const { results: slice, meta } = paginateResults(results, page, DEFAULT_PAGE_SIZE);
             // 7. Warning System
-            // If query contains '/' but no explicit path provided, warn user.
             let warning = undefined;
             if (query.includes('/') && searchResult.count > 0 && !explicitPath && !isPathQuery) {
                 warning = "Query contains path characters. For exact path matching, use the 'path' parameter.";
@@ -262,8 +236,6 @@ export class OramaSearchService {
                 results: slice,
                 meta: {
                     ...meta,
-                    // [Fix] Report the actual filtered count, not the Orama raw candidate count.
-                    // This allows clients (and tests) to know how many "relevant" items exist.
                     total: filteredTotal
                 },
                 warning
@@ -279,7 +251,35 @@ export class OramaSearchService {
         if (!this.db)
             return null;
         try {
-            // [Fix] Use 'term' search on 'path' property + manual filtering
+            // Try lookup first (fast path)
+            if (method) {
+                const id = `${method}:${path}`;
+                const content = this.lookup.get(id);
+                if (content) {
+                    const metadata = {
+                        resourceType: undefined,
+                        actionType: undefined,
+                        score: 1.0,
+                        operationId: content.operationId,
+                        tags: content.tags
+                    };
+                    // Get resourceType/actionType from index
+                    const result = await search(this.db, {
+                        term: path,
+                        properties: ['path'],
+                        limit: 20
+                    });
+                    for (const hit of result.hits) {
+                        if (hit.document.path === path && hit.document.method === method) {
+                            metadata.resourceType = hit.document.resourceType;
+                            metadata.actionType = hit.document.actionType;
+                            break;
+                        }
+                    }
+                    return { content, metadata };
+                }
+            }
+            // Fallback: search index
             const result = await search(this.db, {
                 term: path,
                 properties: ['path'],
@@ -288,11 +288,12 @@ export class OramaSearchService {
             if (result.count > 0) {
                 for (const hit of result.hits) {
                     if (hit.document.path === path && (!method || hit.document.method === method)) {
-                        const content = JSON.parse(hit.document.jsonBlob);
+                        const id = hit.document.id;
+                        const content = this.lookup.get(id) || { path, method: hit.document.method, description: hit.document.description };
                         const metadata = {
                             resourceType: hit.document.resourceType,
                             actionType: hit.document.actionType,
-                            score: 1.0, // Exact lookups have max confidence
+                            score: 1.0,
                             operationId: content.operationId,
                             tags: content.tags
                         };
@@ -311,26 +312,14 @@ export class OramaSearchService {
         await this.initPromise;
         if (!this.db)
             return [];
-        // Quick implementation: Since Orama facets might need schema support,
-        // and we have small data, we can just aggregate manually or return hardcoded list if known.
-        // For now, let's return a placeholder or scan top results.
-        // Ideally, we should have indexed 'category'. 
-        // Let's try to return unique tags from all docs? Too expensive.
-        // Returning empty or basic list for now as per "Progressive Exploration" requires categories.
-        // Let's hack it: search everything (limit 1000) and aggregate tags/categories.
-        const result = await search(this.db, {
-            limit: 1000 // Get all
-        });
         const categories = new Set();
-        result.hits.forEach((hit) => {
-            const data = JSON.parse(hit.document.jsonBlob);
-            // data.tags is array, data.category is string (if injected, but we didn't inject category into individual endpoints)
-            // Check core.json structure again. "tags" are available in endpoint.
-            if (data.tags && Array.isArray(data.tags)) {
-                data.tags.forEach((t) => categories.add(t));
+        // Use lookup map to aggregate tags
+        for (const endpoint of this.lookup.values()) {
+            if (endpoint.tags && Array.isArray(endpoint.tags)) {
+                endpoint.tags.forEach((t) => categories.add(t));
             }
-        });
-        return Array.from(categories).map(c => ({ name: c, count: 0 })); // Count not implemented
+        }
+        return Array.from(categories).map(c => ({ name: c, count: 0 }));
     }
     detectIntent(query) {
         const lower = query.toLowerCase();
@@ -344,12 +333,8 @@ export class OramaSearchService {
             }
         }
         // Resource Detection
-        // Simple lookup against known headers or extracting main noun
-        let resource = undefined; // [Fix] Explicit declaration for scope visibility
+        let resource = undefined;
         // [Round 13 Refactoring] Longest Match Strategy
-        // Issue: "project members" contains "project" (7 chars) and "member" (6 chars used in logic).
-        // If we just loop, we might hit 'project' first and stop.
-        // Solution: Sort all candidate matches by length desc, or pick the longest one.
         const potentialResources = [];
         // [Final Plan] Reverse Lookup from RESOURCE_ALIASES
         for (const [resType, aliases] of Object.entries(RESOURCE_ALIASES)) {
@@ -370,9 +355,16 @@ export class OramaSearchService {
         if (potentialResources.length > 0) {
             resource = potentialResources[0].type;
         }
+        // [Heuristic] Compound resource detection:
+        // "worksheet" + "excel" → prefer 'worksheet-excel' over either alone
+        if (lower.includes('worksheet') && lower.includes('excel')) {
+            resource = 'worksheet-excel';
+        }
+        // "worksheet" + "failure mode" → keep as 'worksheet' (not failure-mode)
+        if (lower.includes('worksheet') && (lower.includes('failure mode') || lower.includes('failuremode'))) {
+            resource = 'worksheet';
+        }
         // [Heuristic] If resource is found but action is ambiguous, default to 'list'
-        // This prioritizes "List <Resource>" endpoints (v1) over "Get <Resource>" (v2)
-        // which helps disambiguate queries like "organization" (Noun) -> Show me the list.
         if (!action && resource) {
             action = 'list';
         }
@@ -381,9 +373,6 @@ export class OramaSearchService {
             resource = 'project';
         }
         // [Fix] Auth Actions imply 'auth' resource, overriding 'user'
-        // Example: "user login", "user sign out" -> Should target 'auth', not 'user'
-        // [Fix] Auth Actions imply 'auth' resource, overriding 'user'
-        // Example: "user login" -> 'auth'. But "third party login" -> 'oauth' (Respect explicit oauth intent)
         if (['login', 'logout'].includes(action || '') && resource !== 'oauth') {
             resource = 'auth';
         }

package/dist/services/search/schema.js

@@ -1,17 +1,10 @@
 export const endpointSchema = {
-    id: 'string', // Unique ID: method + path
+    id: 'string',
     path: 'string',
     method: 'string',
-    version: 'string', // v1, v2
-    summary: 'string',
+    version: 'string',
     description: 'string',
-    // Vector embedding (384 dimensions for Xenova/all-MiniLM-L6-v2)
     embedding: 'vector[384]',
-    // Keywords including synonyms for better text matching
-    keywords: 'string',
-    // Full JSON content stored as string to avoid schema complexity
-    jsonBlob: 'string',
-    // Structural Metadata for precise filtering
-    resourceType: 'string', // e.g. 'project', 'block-diagram'
-    actionType: 'string' // e.g. 'list', 'create', 'read', 'update', 'delete', 'other'
+    resourceType: 'string',
+    actionType: 'string',
 };

package/dist/synonyms.js

@@ -14,7 +14,8 @@ export const RESOURCE_ALIASES = {
     'division': ['organization', 'org', 'department', 'group', 'sector', 'unit'],
     'knowledge': ['knowledge', 'knowledge base', 'category'], // [R17] New Resource Support + Category Mapping
     'project': ['workspace', 'repo', 'application', 'app'], // [R13] Removed 'system' to avoid conflict
-    'system': ['system', 'health', 'status'], // [R13] Added distinct system resource
+    'system': ['system', 'health', 'status', 'health check', 'heartbeat', 'ping', 'deployment'],
+    'context-version': ['context version', 'context-version', 'build version', 'deployment version'], // Dedicated sub-resource
     'auth': ['security', 'credential', 'token', 'access', 'password'], // [R17] Removed 'login' to avoid conflict with action
     'oauth': ['third party', 'social login', 'google', 'github', 'oauth'], // [R17] Dedicated OAuth resource
     // FMEA Domain
@@ -27,12 +28,15 @@ export const RESOURCE_ALIASES = {
     'user': ['person', 'account', 'profile'], // Removed 'member' from here to avoid conflict
     'member': ['member', 'project member', 'team'], // [R13] Distinct resource type matching indexer
     'document': ['file', 'attachment', 'upload', 'paperwork', 'files'], // [R13] Added plural 'files'
-    'api-key': ['key', 'secret', 'token', 'credential', 'usage', 'metrics', 'logs', 'stats'], // [R15] Added usage metrics aliases
+    'api-key': ['key', 'secret', 'credential'], // [R15] Cleaned: monitoring keywords (usage/metrics/logs/stats) moved to ACTION_KEYWORDS only
     'worksheet-template': ['template', 'sheet structure'], // [R18] Keep clean - column/header expansion handled by SYNONYM_GROUPS
     'action-status-template': ['status template', 'action status'], // [R15]
-    'join-request': ['join', 'invite', 'add user', 'member request'], // [R16]
+    'join-request': ['join', 'invite', 'add user', 'member request', 'pending', 'join request'], // [R16]
     'excel': ['excel', 'spreadsheet', 'csv'], // [R16]
+    'worksheet-excel': ['worksheet excel', 'excel worksheet', 'worksheet export', 'worksheet download'], // Worksheet Excel import/export
     'synonym': ['synonyms', 'synonym'], // [Fix] Key must match singular resourceType for boosting
+    'fourm': ['4m', 'four m', '4m analysis', 'man machine material environment'], // 4M Analysis
+    'term': ['term', 'terms', 'taxonomy', 'terminology', 'classification', 'glossary'], // Term tree management
 };
 export const SYNONYM_GROUPS = {
     // Read / Retrieve

package/dist/utils/ScoreCalculator.js

@@ -20,7 +20,10 @@ export class ScoreCalculator {
         'knowledge': ['category'],
         'category': ['knowledge'],
         'oauth': ['auth'],
-        'auth': ['oauth']
+        'auth': ['oauth'],
+        'context-version': ['system'],
+        'system': ['context-version'],
+        'join-request': ['project', 'user', 'member']
         // Note: Inverse is NOT necessarily true (searching for 'document' shouldn't show 'project' root unless necessary, but let's be strict for now)
     };
     /**