il2cpp-dump-analyzer-mcp
Version:
Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games
233 lines • 7.72 kB
JavaScript
;
/**
* MCP Response Formatting Utilities
* Standardizes response formatting across all MCP tools to eliminate duplication
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.MCPResponseFormatter = void 0;
/**
* MCP response formatting utilities
*/
class MCPResponseFormatter {
/**
* Format a simple text response
*/
static formatTextResponse(content, metadata) {
const text = typeof content === 'string' ? content : this.safeJsonStringify(content, 2);
return {
content: [{
type: 'text',
text,
...(metadata && { metadata })
}]
};
}
/**
* Format search results from vector store
*/
static formatSearchResults(results, searchQuery, appliedFilters = {}, metadata = {}) {
const searchMetadata = {
searchQuery,
appliedFilters,
resultCount: results.length,
...metadata
};
if (results.length === 0) {
return this.formatTextResponse({
message: 'No results found',
searchQuery,
appliedFilters,
suggestions: [
'Try using different search terms',
'Remove or adjust filters',
'Use broader search criteria',
'Check spelling and syntax'
]
}, searchMetadata);
}
// Format results with consistent structure
const formattedResults = results.map((doc, index) => ({
rank: index + 1,
name: doc.metadata.name || 'Unknown',
fullName: doc.metadata.fullName || doc.metadata.name || 'Unknown',
type: doc.metadata.type || 'unknown',
namespace: doc.metadata.namespace || 'global',
content: doc.pageContent,
metadata: {
...doc.metadata,
relevanceScore: doc.metadata.score || 0
}
}));
return this.formatTextResponse({
summary: {
totalResults: results.length,
searchQuery,
appliedFilters
},
results: formattedResults,
metadata: searchMetadata
});
}
/**
* Format error response with consistent structure
*/
static formatErrorResponse(error, toolName, parameters) {
const errorMessage = error instanceof Error ? error.message : error;
return this.formatTextResponse({
error: true,
message: errorMessage,
toolName,
parameters,
timestamp: new Date().toISOString(),
suggestions: [
'Check parameter values and types',
'Verify required parameters are provided',
'Review tool documentation for correct usage',
'Try with simpler parameters first'
]
});
}
/**
* Format analysis results with summary and details
*/
static formatAnalysisResults(analysis, toolName, parameters, executionTime) {
const metadata = {
toolName,
executionTime: executionTime || 0,
parametersUsed: parameters
};
return this.formatTextResponse(analysis, metadata);
}
/**
* Format generation results (for code generation tools)
*/
static formatGenerationResults(generatedCode, metadata) {
return this.formatTextResponse({
success: true,
generatedCode,
metadata: {
...metadata,
timestamp: new Date().toISOString(),
codeLength: generatedCode.length,
lineCount: generatedCode.split('\n').length
}
});
}
/**
* Format list results with pagination info
*/
static formatListResults(items, pagination = {}, metadata = {}) {
return this.formatTextResponse({
items,
pagination: {
count: items.length,
...pagination
},
metadata
});
}
/**
* Format resource response for MCP resource handlers
*/
static formatResourceResponse(results, resourceUri, queryString, filter) {
return {
contents: results.map(doc => ({
uri: `il2cpp://${encodeURIComponent(doc.metadata.fullName || doc.metadata.name)}`,
text: doc.pageContent,
metadata: {
...doc.metadata,
searchQuery: queryString,
appliedFilters: filter,
resultCount: results.length,
resourceUri
}
}))
};
}
/**
* Format validation results with errors and warnings
*/
static formatValidationResults(isValid, errors = [], warnings = [], data) {
return this.formatTextResponse({
valid: isValid,
errors,
warnings,
...(data && { data })
});
}
/**
* Format pattern detection results
*/
static formatPatternResults(detectedPatterns, summary, metadata) {
return this.formatTextResponse({
detectedPatterns,
summary,
metadata: {
...metadata,
timestamp: new Date().toISOString()
}
});
}
/**
* Safe JSON stringify with circular reference handling
*/
static safeJsonStringify(obj, indent = 0) {
try {
const seen = new WeakSet();
return JSON.stringify(obj, (key, val) => {
if (val != null && typeof val === 'object') {
if (seen.has(val)) {
return '[Circular Reference]';
}
seen.add(val);
}
return val;
}, indent);
}
catch (error) {
return `[JSON Stringify Error: ${error instanceof Error ? error.message : 'Unknown error'}]`;
}
}
/**
* Add execution timing to response
*/
static addExecutionTiming(response, startTime, toolName) {
const executionTime = Date.now() - startTime;
if (response.content[0] && response.content[0].metadata) {
response.content[0].metadata.executionTime = executionTime;
response.content[0].metadata.toolName = toolName;
}
return response;
}
/**
* Add warnings to response
*/
static addWarnings(response, warnings) {
if (warnings.length > 0 && response.content[0]) {
if (!response.content[0].metadata) {
response.content[0].metadata = {};
}
response.content[0].metadata.warnings = warnings;
}
return response;
}
/**
* Create a standardized "not found" response
*/
static formatNotFoundResponse(searchTerm, searchType = 'item') {
return this.formatTextResponse({
found: false,
message: `${searchType} '${searchTerm}' not found`,
searchTerm,
searchType,
suggestions: [
'Check the spelling of the search term',
'Try using a partial name or pattern',
'Use the search_code tool to explore available items',
'Verify the item exists in the loaded IL2CPP dump'
]
});
}
}
exports.MCPResponseFormatter = MCPResponseFormatter;
//# sourceMappingURL=mcp-response-formatter.js.map