vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
351 lines (350 loc) • 13.8 kB
JavaScript
import { BaseLanguageHandler } from './base.js';
import { getNodeText } from '../astAnalyzer.js';
import logger from '../../../logger.js';
export class KotlinHandler extends BaseLanguageHandler {
getFunctionQueryPatterns() {
return [
'function_declaration',
'function_literal',
'lambda_expression',
'anonymous_function'
];
}
getClassQueryPatterns() {
return [
'class_declaration',
'object_declaration',
'interface_declaration',
'enum_class'
];
}
getImportQueryPatterns() {
return [
'import_header',
'package_header'
];
}
extractFunctionName(node, sourceCode, _options) {
try {
if (node.type === 'function_declaration') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
if (name.startsWith('test') || this.hasAnnotation(node, 'Test')) {
return `test_${name}`;
}
if (this.isAndroidLifecycleMethod(name)) {
return `lifecycle_${name}`;
}
if (this.isExtensionFunction(node, sourceCode)) {
const receiverType = this.getReceiverType(node, sourceCode);
return `${receiverType}_${name}`;
}
return name;
}
}
if (node.type === 'lambda_expression' || node.type === 'function_literal' || node.type === 'anonymous_function') {
if (node.parent?.type === 'property_declaration') {
const nameNode = node.parent.childForFieldName('name');
if (nameNode) {
return getNodeText(nameNode, sourceCode);
}
}
if (node.parent?.type === 'value_argument' &&
node.parent.parent?.type === 'value_arguments' &&
node.parent.parent.parent?.type === 'call_expression') {
const funcNode = node.parent.parent.parent.childForFieldName('expression');
if (funcNode) {
const funcName = getNodeText(funcNode, sourceCode);
if (['map', 'filter', 'forEach', 'apply', 'let', 'run', 'with', 'also'].includes(funcName)) {
return `${funcName}_lambda`;
}
}
}
return 'lambda';
}
return 'anonymous';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin function name');
return 'anonymous';
}
}
hasAnnotation(node, annotationName) {
try {
const modifierListNode = node.childForFieldName('modifiers');
if (!modifierListNode)
return false;
for (let i = 0; i < modifierListNode.childCount; i++) {
const modifier = modifierListNode.child(i);
if (modifier?.type === 'annotation' && modifier.text.includes(`@${annotationName}`)) {
return true;
}
}
return false;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error checking Kotlin annotation');
return false;
}
}
isAndroidLifecycleMethod(name) {
const lifecycleMethods = [
'onCreate',
'onStart',
'onResume',
'onPause',
'onStop',
'onDestroy',
'onCreateView',
'onViewCreated'
];
return lifecycleMethods.includes(name);
}
isExtensionFunction(node, _sourceCode) {
try {
const receiverTypeNode = node.childForFieldName('receiver_type');
return !!receiverTypeNode;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error checking if Kotlin function is extension function');
return false;
}
}
getReceiverType(node, sourceCode) {
try {
const receiverTypeNode = node.childForFieldName('receiver_type');
if (receiverTypeNode) {
return getNodeText(receiverTypeNode, sourceCode);
}
return 'Unknown';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error getting Kotlin receiver type');
return 'Unknown';
}
}
extractClassName(node, sourceCode) {
try {
if (node.type === 'class_declaration' ||
node.type === 'interface_declaration' ||
node.type === 'enum_class') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
return getNodeText(nameNode, sourceCode);
}
}
else if (node.type === 'object_declaration') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
return `Object_${getNodeText(nameNode, sourceCode)}`;
}
}
return 'AnonymousClass';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin class name');
return 'AnonymousClass';
}
}
extractParentClass(node, sourceCode) {
try {
if (node.type === 'class_declaration') {
const parentEntryNode = node.childForFieldName('parent_entry');
if (parentEntryNode) {
const typeNode = parentEntryNode.childForFieldName('type');
if (typeNode) {
return getNodeText(typeNode, sourceCode);
}
}
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin parent class');
return undefined;
}
}
extractImplementedInterfaces(node, sourceCode) {
try {
if (node.type === 'class_declaration') {
const interfaces = [];
const parentEntriesNode = node.childForFieldName('parent_entries');
if (parentEntriesNode) {
parentEntriesNode.children.forEach(entry => {
if (entry.type === 'parent_entry') {
const typeNode = entry.childForFieldName('type');
if (typeNode) {
interfaces.push(getNodeText(typeNode, sourceCode));
}
}
});
}
if (interfaces.length > 0 && this.extractParentClass(node, sourceCode)) {
interfaces.shift();
}
return interfaces.length > 0 ? interfaces : undefined;
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin implemented interfaces');
return undefined;
}
}
extractImportPath(node, sourceCode) {
try {
if (node.type === 'import_header') {
const identifierNode = node.childForFieldName('identifier');
if (identifierNode) {
return getNodeText(identifierNode, sourceCode);
}
}
else if (node.type === 'package_header') {
const identifierNode = node.childForFieldName('identifier');
if (identifierNode) {
return getNodeText(identifierNode, sourceCode);
}
}
return 'unknown';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin import path');
return 'unknown';
}
}
extractImportedItems(node, sourceCode) {
try {
if (node.type === 'import_header') {
const identifierNode = node.childForFieldName('identifier');
if (identifierNode) {
const fullPath = getNodeText(identifierNode, sourceCode);
const parts = fullPath.split('.');
const isWildcard = fullPath.endsWith('.*');
const aliasNode = node.childForFieldName('alias');
const alias = aliasNode ? getNodeText(aliasNode, sourceCode) : undefined;
if (isWildcard) {
const basePath = fullPath.substring(0, fullPath.length - 2);
return [{
name: '*',
path: basePath,
alias: alias,
isDefault: false,
isNamespace: true,
nodeText: node.text,
packageName: basePath
}];
}
else {
const name = parts[parts.length - 1];
const packageName = parts.slice(0, parts.length - 1).join('.');
return [{
name: alias || name,
path: fullPath,
alias: alias,
isDefault: false,
isNamespace: false,
nodeText: node.text,
packageName: packageName
}];
}
}
}
else if (node.type === 'package_header') {
const identifierNode = node.childForFieldName('identifier');
if (identifierNode) {
const packagePath = getNodeText(identifierNode, sourceCode);
return [{
name: packagePath,
path: packagePath,
isDefault: false,
isNamespace: true,
nodeText: node.text,
isPackageDeclaration: true
}];
}
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin imported items');
return undefined;
}
}
extractFunctionComment(node, _sourceCode) {
try {
const current = node;
let prev = current.previousNamedSibling;
while (prev && prev.type !== 'comment') {
prev = prev.previousNamedSibling;
}
if (prev && prev.type === 'comment' && prev.text.startsWith('/**')) {
return this.parseKDocComment(prev.text);
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin function comment');
return undefined;
}
}
extractClassComment(node, _sourceCode) {
try {
const current = node;
let prev = current.previousNamedSibling;
while (prev && prev.type !== 'comment') {
prev = prev.previousNamedSibling;
}
if (prev && prev.type === 'comment' && prev.text.startsWith('/**')) {
return this.parseKDocComment(prev.text);
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Kotlin class comment');
return undefined;
}
}
parseKDocComment(comment) {
try {
const text = comment.substring(3, comment.length - 2);
const lines = text.split('\n')
.map(line => line.trim().replace(/^\*\s*/, ''))
.filter(line => !line.startsWith('@'));
return lines.join(' ').trim();
}
catch (error) {
logger.warn({ err: error }, 'Error parsing KDoc comment');
return comment;
}
}
detectFramework(sourceCode) {
try {
if (sourceCode.includes('import android.') ||
sourceCode.includes('extends Activity') ||
sourceCode.includes('extends Fragment')) {
return 'android';
}
if (sourceCode.includes('import io.ktor.') ||
sourceCode.includes('embeddedServer') ||
sourceCode.includes('routing {')) {
return 'ktor';
}
if (sourceCode.includes('import org.springframework.') ||
sourceCode.includes('@Controller') ||
sourceCode.includes('@Service')) {
return 'spring';
}
if (sourceCode.includes('import androidx.compose.') ||
sourceCode.includes('@Composable') ||
sourceCode.includes('setContent {')) {
return 'compose';
}
return null;
}
catch (error) {
logger.warn({ err: error }, 'Error detecting Kotlin framework');
return null;
}
}
}