311 lines
10 KiB
JavaScript
311 lines
10 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
/**
|
|
* Phase 3: Integration and Syntax Validation
|
|
* Safely integrate new tools into endpoints.js with proper syntax validation
|
|
*/
|
|
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
|
|
class Phase3Integration {
|
|
constructor() {
|
|
this.auditResults = null;
|
|
this.newToolsByAuthType = {};
|
|
this.parameterUpdates = [];
|
|
}
|
|
|
|
/**
|
|
* Load audit results
|
|
*/
|
|
loadAuditResults() {
|
|
try {
|
|
console.log('📖 Loading audit results...');
|
|
const resultsPath = path.join(process.cwd(), 'comprehensive-audit-results.json');
|
|
const resultsContent = fs.readFileSync(resultsPath, 'utf8');
|
|
this.auditResults = JSON.parse(resultsContent);
|
|
|
|
console.log(`✅ Loaded audit results: ${this.auditResults.newTools.length} new tools`);
|
|
|
|
// Group new tools by auth type
|
|
this.auditResults.newTools.forEach(tool => {
|
|
if (!this.newToolsByAuthType[tool.authType]) {
|
|
this.newToolsByAuthType[tool.authType] = [];
|
|
}
|
|
this.newToolsByAuthType[tool.authType].push(tool);
|
|
});
|
|
|
|
return true;
|
|
} catch (error) {
|
|
console.error('❌ Error loading audit results:', error.message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert tool to properly formatted endpoint string
|
|
*/
|
|
toolToEndpointString(tool) {
|
|
const paramEntries = Object.entries(tool.parameters);
|
|
|
|
let paramString = '{}';
|
|
if (paramEntries.length > 0) {
|
|
const paramLines = paramEntries.map(([name, param]) => {
|
|
return ` ${name}: {
|
|
type: "${param.type}",
|
|
required: ${param.required},
|
|
description: "${param.description}",
|
|
}`;
|
|
});
|
|
paramString = `{
|
|
${paramLines.join(',\n')}
|
|
}`;
|
|
}
|
|
|
|
return ` {
|
|
path: "${tool.path}",
|
|
method: "${tool.method}",
|
|
controller: "${tool.controller}",
|
|
category: ${tool.category},
|
|
description: "${tool.description}",
|
|
parameters: ${paramString},
|
|
}`;
|
|
}
|
|
|
|
/**
|
|
* Add new endpoints to specific auth type section
|
|
*/
|
|
addEndpointsToSection(content, sectionName, newTools) {
|
|
if (newTools.length === 0) return content;
|
|
|
|
console.log(`📋 Adding ${newTools.length} endpoints to ${sectionName}`);
|
|
|
|
// Generate endpoint strings
|
|
const endpointStrings = newTools.map(tool => this.toolToEndpointString(tool));
|
|
|
|
// Find the section
|
|
const sectionRegex = new RegExp(`(export const ${sectionName}\\s*=\\s*\\[)([\\s\\S]*?)(\\];)`, 'g');
|
|
const match = sectionRegex.exec(content);
|
|
|
|
if (match) {
|
|
const beforeSection = match[1];
|
|
const sectionContent = match[2];
|
|
const afterSection = match[3];
|
|
|
|
// Add new endpoints at the end of the section
|
|
const newSection = `
|
|
// ===== NEW ENDPOINTS FROM API-DOCS.JSON COMPREHENSIVE AUDIT =====
|
|
${endpointStrings.join(',\n')}`;
|
|
|
|
const updatedSection = sectionContent.trimEnd() + ',' + newSection + '\n';
|
|
const replacement = beforeSection + updatedSection + afterSection;
|
|
|
|
return content.replace(match[0], replacement);
|
|
} else {
|
|
console.log(` ⚠️ Could not find ${sectionName} section`);
|
|
return content;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update parameter mismatches in existing endpoints
|
|
*/
|
|
updateParameterMismatches(content) {
|
|
console.log('\n🔧 Updating parameter mismatches...');
|
|
|
|
let updatedContent = content;
|
|
let updateCount = 0;
|
|
|
|
this.auditResults.parameterMismatches.forEach(mismatch => {
|
|
const { endpoint, tool, missing, different } = mismatch;
|
|
|
|
// Find the specific endpoint in the content
|
|
const pathPattern = `path:\\s*["']${tool.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}["']`;
|
|
const methodPattern = `method:\\s*["']${tool.method}["']`;
|
|
|
|
// Create a more specific regex to find this exact endpoint
|
|
const endpointRegex = new RegExp(
|
|
`(\\{[\\s\\S]*?${pathPattern}[\\s\\S]*?${methodPattern}[\\s\\S]*?parameters:\\s*\\{)([\\s\\S]*?)(\\}[\\s\\S]*?\\})`,
|
|
'g'
|
|
);
|
|
|
|
const match = endpointRegex.exec(updatedContent);
|
|
if (match) {
|
|
const beforeParams = match[1];
|
|
const currentParams = match[2];
|
|
const afterParams = match[3];
|
|
|
|
// Add missing parameters
|
|
const newParams = [];
|
|
missing.forEach(param => {
|
|
const cleanName = param.name.replace(/[^a-zA-Z0-9_]/g, '_');
|
|
newParams.push(` ${cleanName}: {
|
|
type: "${param.type}",
|
|
required: ${param.required},
|
|
description: "${param.description || 'Parameter'}",
|
|
}`);
|
|
});
|
|
|
|
// Update different parameters
|
|
let updatedParams = currentParams;
|
|
different.forEach(diff => {
|
|
const paramName = diff.name;
|
|
const apiParam = diff.api;
|
|
|
|
// Update the parameter definition
|
|
const paramRegex = new RegExp(
|
|
`(${paramName}:\\s*\\{[^}]*type:\\s*["'])([^"']+)(["'][^}]*\\})`,
|
|
'g'
|
|
);
|
|
updatedParams = updatedParams.replace(paramRegex, `$1${apiParam.type}$3`);
|
|
|
|
const requiredRegex = new RegExp(
|
|
`(${paramName}:\\s*\\{[^}]*required:\\s*)(true|false)`,
|
|
'g'
|
|
);
|
|
updatedParams = updatedParams.replace(requiredRegex, `$1${apiParam.required}`);
|
|
});
|
|
|
|
// Combine existing and new parameters
|
|
const finalParams = updatedParams.trim() +
|
|
(newParams.length > 0 ? (updatedParams.trim() ? ',\n' : '') + newParams.join(',\n') : '');
|
|
|
|
const replacement = beforeParams + finalParams + afterParams;
|
|
updatedContent = updatedContent.replace(match[0], replacement);
|
|
updateCount++;
|
|
|
|
console.log(` ✅ Updated ${tool.path} (${missing.length} missing, ${different.length} different)`);
|
|
}
|
|
});
|
|
|
|
console.log(`✅ Updated ${updateCount} endpoints with parameter fixes`);
|
|
return updatedContent;
|
|
}
|
|
|
|
/**
|
|
* Validate JavaScript syntax
|
|
*/
|
|
validateSyntax(content) {
|
|
try {
|
|
// Write to temporary file and try to require it
|
|
const tempPath = path.join(process.cwd(), 'temp-endpoints-validation.js');
|
|
fs.writeFileSync(tempPath, content);
|
|
|
|
// Try to parse as module (basic syntax check)
|
|
const { execSync } = require('child_process');
|
|
execSync(`node -c "${tempPath}"`, { stdio: 'pipe' });
|
|
|
|
// Clean up
|
|
fs.unlinkSync(tempPath);
|
|
|
|
console.log('✅ Syntax validation passed');
|
|
return true;
|
|
} catch (error) {
|
|
console.error('❌ Syntax validation failed:', error.message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create backup of current endpoints.js
|
|
*/
|
|
createBackup() {
|
|
try {
|
|
const endpointsPath = path.join(process.cwd(), 'src/config/endpoints.js');
|
|
const backupPath = `src/config/endpoints_backup_phase3_${Date.now()}.js`;
|
|
|
|
fs.copyFileSync(endpointsPath, backupPath);
|
|
console.log(`💾 Created backup: ${backupPath}`);
|
|
return backupPath;
|
|
} catch (error) {
|
|
console.error('❌ Error creating backup:', error.message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Run Phase 3 integration
|
|
*/
|
|
async runIntegration() {
|
|
console.log('🚀 PHASE 3: INTEGRATION AND SYNTAX VALIDATION\n');
|
|
|
|
// Load audit results
|
|
if (!this.loadAuditResults()) return false;
|
|
|
|
// Create backup
|
|
const backupPath = this.createBackup();
|
|
if (!backupPath) return false;
|
|
|
|
try {
|
|
// Load current endpoints.js
|
|
const endpointsPath = path.join(process.cwd(), 'src/config/endpoints.js');
|
|
let content = fs.readFileSync(endpointsPath, 'utf8');
|
|
|
|
// Update parameter mismatches first
|
|
content = this.updateParameterMismatches(content);
|
|
|
|
// Add new endpoints for each auth type
|
|
Object.entries(this.newToolsByAuthType).forEach(([authType, tools]) => {
|
|
const sectionName = `${authType.toUpperCase()}_ENDPOINTS`;
|
|
content = this.addEndpointsToSection(content, sectionName, tools);
|
|
console.log(` ✅ Added ${tools.length} endpoints to ${sectionName}`);
|
|
});
|
|
|
|
// Validate syntax
|
|
if (!this.validateSyntax(content)) {
|
|
console.error('❌ Syntax validation failed, restoring backup');
|
|
fs.copyFileSync(backupPath, endpointsPath);
|
|
return false;
|
|
}
|
|
|
|
// Write updated content
|
|
fs.writeFileSync(endpointsPath, content);
|
|
console.log('✅ Updated endpoints.js successfully');
|
|
|
|
// Generate summary
|
|
const totalNewTools = Object.values(this.newToolsByAuthType).reduce((sum, tools) => sum + tools.length, 0);
|
|
const totalParameterFixes = this.auditResults.parameterMismatches.length;
|
|
|
|
console.log('\n📊 INTEGRATION SUMMARY:');
|
|
console.log(`✅ Added ${totalNewTools} new endpoints`);
|
|
console.log(`✅ Fixed ${totalParameterFixes} parameter mismatches`);
|
|
console.log(`✅ Syntax validation passed`);
|
|
console.log(`💾 Backup created: ${backupPath}`);
|
|
|
|
// Show distribution by auth type
|
|
console.log('\n📋 New Tools by Authentication Type:');
|
|
Object.entries(this.newToolsByAuthType).forEach(([authType, tools]) => {
|
|
console.log(` ${authType.toUpperCase()}: ${tools.length} tools`);
|
|
});
|
|
|
|
return true;
|
|
} catch (error) {
|
|
console.error('❌ Error during integration:', error.message);
|
|
|
|
// Restore backup on error
|
|
try {
|
|
fs.copyFileSync(backupPath, endpointsPath);
|
|
console.log('🔄 Restored backup due to error');
|
|
} catch (restoreError) {
|
|
console.error('❌ Failed to restore backup:', restoreError.message);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run Phase 3
|
|
const integration = new Phase3Integration();
|
|
integration.runIntegration().then(success => {
|
|
if (success) {
|
|
console.log('\n🎉 Phase 3 integration completed successfully!');
|
|
console.log('\n📋 Next steps:');
|
|
console.log('1. Run test-basic.js to verify functionality');
|
|
console.log('2. Update MCP-TOOLS-REFERENCE.md documentation');
|
|
console.log('3. Test new endpoints with real API calls');
|
|
} else {
|
|
console.log('\n❌ Phase 3 integration failed');
|
|
}
|
|
});
|