mcp-ai-agent-guidelines
Version:
A comprehensive Model Context Protocol server providing advanced tools, resources, and prompts for implementing AI agent best practices
155 lines • 5.05 kB
JavaScript
/**
* Language Detection Service
*
* Provides extensible language detection using a registry pattern
*/
export class LanguageRegistry {
static instance;
analyzers = new Map();
constructor() {
// Initialize with default language analyzers
this.registerDefaultLanguages();
}
static getInstance() {
if (!LanguageRegistry.instance) {
LanguageRegistry.instance = new LanguageRegistry();
}
return LanguageRegistry.instance;
}
/**
* Register a language analyzer
*/
register(analyzer) {
this.analyzers.set(analyzer.name, analyzer);
}
/**
* Get analyzer by language name
*/
getAnalyzer(language) {
return this.analyzers.get(language);
}
/**
* Detect language from code content
*/
detectLanguage(code) {
// Try each analyzer's detect method
for (const [name, analyzer] of this.analyzers.entries()) {
if (analyzer.detect(code)) {
return name;
}
}
return "Unknown";
}
/**
* Get all registered languages
*/
getRegisteredLanguages() {
return Array.from(this.analyzers.keys());
}
registerDefaultLanguages() {
// Import and register default language analyzers
// These will be implemented in separate files
// For now, keep the detection logic inline for minimal changes
// Register Java before Python to avoid false detection
this.register({
name: "Java",
extensions: [".java"],
detect: (code) => {
return code.includes("public class") || code.includes("private class");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "TypeScript/JavaScript",
extensions: [".ts", ".tsx", ".js", ".jsx"],
detect: (code) => {
return (code.includes("function") ||
code.includes("const") ||
code.includes("=>") ||
(code.includes("import") && code.includes("from")));
},
extractSymbols: () => [], // Will be implemented in separate module
extractDependencies: () => [], // Will be implemented in separate module
});
this.register({
name: "Python",
extensions: [".py"],
detect: (code) => {
return ((code.includes("def ") || code.includes("class ")) &&
!code.includes("end") && // Distinguish from Ruby
!code.includes("public class") && // Distinguish from Java
!code.includes("private class") // Distinguish from Java
);
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "Rust",
extensions: [".rs"],
detect: (code) => {
return code.includes("fn ") && code.includes("->");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "Go",
extensions: [".go"],
detect: (code) => {
return code.includes("func ") && code.includes("package");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "Ruby",
extensions: [".rb"],
detect: (code) => {
return code.includes("def ") && code.includes("end");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "PHP",
extensions: [".php"],
detect: (code) => {
return code.includes("<?php");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "C++",
extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp"],
detect: (code) => {
return (code.includes("#include") &&
(code.includes("::") || code.includes("std::")));
},
extractSymbols: () => [],
extractDependencies: () => [],
});
this.register({
name: "C#",
extensions: [".cs"],
detect: (code) => {
return code.includes("namespace") && code.includes("using");
},
extractSymbols: () => [],
extractDependencies: () => [],
});
}
}
/**
* Singleton instance for easy access
*/
export const languageRegistry = LanguageRegistry.getInstance();
/**
* Detect language from code
*/
export function detectLanguage(code) {
return languageRegistry.detectLanguage(code);
}
//# sourceMappingURL=language-detection.js.map