vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
367 lines (366 loc) • 14.7 kB
JavaScript
import { BaseLanguageHandler } from './base.js';
import { getNodeText } from '../astAnalyzer.js';
import logger from '../../../logger.js';
import path from 'path';
export class TomlHandler extends BaseLanguageHandler {
options;
getFunctionQueryPatterns() {
return [
'pair',
'table',
'array_table',
'inline_table'
];
}
getClassQueryPatterns() {
return [
'document',
'table',
'array_table'
];
}
getImportQueryPatterns() {
return [
'pair'
];
}
extractFunctionName(node, sourceCode, _options) {
try {
if (node.type === 'pair') {
const keyNode = node.childForFieldName('key');
if (keyNode) {
const key = getNodeText(keyNode, sourceCode);
if (['run', 'script', 'command', 'exec', 'test', 'build', 'deploy'].includes(key)) {
return `${key}_command`;
}
if (this.isInDependenciesSection(node, sourceCode)) {
return `dependency_${key}`;
}
if (this.isInPackageSection(node, sourceCode)) {
return `package_${key}`;
}
return key;
}
}
if (node.type === 'table') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
if (['dependencies', 'dev-dependencies', 'build-dependencies'].includes(name)) {
return `${name}_section`;
}
else if (name === 'package') {
return 'package_metadata';
}
else if (name === 'profile') {
return 'build_profile';
}
else if (name === 'features') {
return 'feature_flags';
}
else if (name === 'workspace') {
return 'workspace_config';
}
else if (name === 'bin') {
return 'binary_target';
}
else if (name === 'lib') {
return 'library_target';
}
return `table_${name}`;
}
}
if (node.type === 'array_table') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
return `array_table_${name}`;
}
}
if (node.type === 'inline_table') {
if (node.parent?.type === 'pair') {
const keyNode = node.parent.childForFieldName('key');
if (keyNode) {
const key = getNodeText(keyNode, sourceCode);
return `${key}_table`;
}
}
return 'inline_table';
}
return 'toml_element';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting TOML function name');
return 'toml_element';
}
}
isInDependenciesSection(node, sourceCode) {
try {
let current = node;
while (current.parent) {
current = current.parent;
if (current.type === 'table') {
const nameNode = current.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
if (['dependencies', 'dev-dependencies', 'build-dependencies'].includes(name)) {
return true;
}
}
}
}
return false;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error checking if TOML node is in dependencies section');
return false;
}
}
isInPackageSection(node, sourceCode) {
try {
let current = node;
while (current.parent) {
current = current.parent;
if (current.type === 'table') {
const nameNode = current.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
if (name === 'package') {
return true;
}
}
}
}
return false;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error checking if TOML node is in package section');
return false;
}
}
extractClassName(node, sourceCode) {
try {
if (node.type === 'document') {
if (this.isCargoToml()) {
const packageName = this.extractPackageName(node, sourceCode);
if (packageName) {
return `Cargo_${packageName}`;
}
return 'Cargo_Project';
}
if (this.isPyprojectToml()) {
const projectName = this.extractPyprojectName(node, sourceCode);
if (projectName) {
return `Python_${projectName}`;
}
return 'Python_Project';
}
if (this.options?.filePath) {
return `TOML_${path.basename(this.options.filePath, path.extname(this.options.filePath))}`;
}
}
else if (node.type === 'table') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
return `Table_${name}`;
}
}
else if (node.type === 'array_table') {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const name = getNodeText(nameNode, sourceCode);
return `ArrayTable_${name}`;
}
}
return 'TOML_Config';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting TOML class name');
return 'TOML_Config';
}
}
isCargoToml() {
if (this.options?.filePath) {
const filename = path.basename(this.options.filePath).toLowerCase();
return filename === 'cargo.toml';
}
return false;
}
isPyprojectToml() {
if (this.options?.filePath) {
const filename = path.basename(this.options.filePath).toLowerCase();
return filename === 'pyproject.toml';
}
return false;
}
extractPackageName(node, sourceCode) {
try {
for (let i = 0; i < node.childCount; i++) {
const child = node.child(i);
if (child?.type === 'table') {
const nameNode = child.childForFieldName('name');
if (nameNode && getNodeText(nameNode, sourceCode) === 'package') {
for (let j = 0; j < child.childCount; j++) {
const packageChild = child.child(j);
if (packageChild?.type === 'pair') {
const keyNode = packageChild.childForFieldName('key');
if (keyNode && getNodeText(keyNode, sourceCode) === 'name') {
const valueNode = packageChild.childForFieldName('value');
if (valueNode) {
return getNodeText(valueNode, sourceCode).replace(/^["']|["']$/g, '');
}
}
}
}
}
}
}
return null;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting Cargo.toml package name');
return null;
}
}
extractPyprojectName(node, sourceCode) {
try {
for (let i = 0; i < node.childCount; i++) {
const child = node.child(i);
if (child?.type === 'table') {
const nameNode = child.childForFieldName('name');
if (nameNode && getNodeText(nameNode, sourceCode) === 'tool.poetry') {
for (let j = 0; j < child.childCount; j++) {
const poetryChild = child.child(j);
if (poetryChild?.type === 'pair') {
const keyNode = poetryChild.childForFieldName('key');
if (keyNode && getNodeText(keyNode, sourceCode) === 'name') {
const valueNode = poetryChild.childForFieldName('value');
if (valueNode) {
return getNodeText(valueNode, sourceCode).replace(/^["']|["']$/g, '');
}
}
}
}
}
if (nameNode && getNodeText(nameNode, sourceCode) === 'project') {
for (let j = 0; j < child.childCount; j++) {
const projectChild = child.child(j);
if (projectChild?.type === 'pair') {
const keyNode = projectChild.childForFieldName('key');
if (keyNode && getNodeText(keyNode, sourceCode) === 'name') {
const valueNode = projectChild.childForFieldName('value');
if (valueNode) {
return getNodeText(valueNode, sourceCode).replace(/^["']|["']$/g, '');
}
}
}
}
}
}
}
return null;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting pyproject.toml project name');
return null;
}
}
extractImportPath(node, sourceCode) {
try {
if (node.type === 'pair') {
const keyNode = node.childForFieldName('key');
if (keyNode) {
const key = getNodeText(keyNode, sourceCode);
if (key === 'path' || key === 'include' || key === 'import' || key === 'from') {
const valueNode = node.childForFieldName('value');
if (valueNode) {
return getNodeText(valueNode, sourceCode).replace(/^["']|["']$/g, '');
}
}
}
}
return 'unknown';
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting TOML import path');
return 'unknown';
}
}
extractFunctionComment(node, sourceCode) {
try {
const current = node;
let prev = current.previousNamedSibling;
while (prev && prev.type !== 'comment') {
prev = prev.previousNamedSibling;
}
if (prev && prev.type === 'comment') {
const commentText = getNodeText(prev, sourceCode);
return commentText
.replace(/^#\s*/mg, '')
.trim();
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting TOML function comment');
return undefined;
}
}
extractClassComment(node, sourceCode) {
try {
if (node.type === 'document') {
const firstChild = node.firstChild;
if (firstChild && firstChild.type === 'comment') {
const commentText = getNodeText(firstChild, sourceCode);
return commentText
.replace(/^#\s*/mg, '')
.trim();
}
}
else if (node.type === 'table' || node.type === 'array_table') {
const current = node;
let prev = current.previousNamedSibling;
while (prev && prev.type !== 'comment') {
prev = prev.previousNamedSibling;
}
if (prev && prev.type === 'comment') {
const commentText = getNodeText(prev, sourceCode);
return commentText
.replace(/^#\s*/mg, '')
.trim();
}
}
return undefined;
}
catch (error) {
logger.warn({ err: error, nodeType: node.type }, 'Error extracting TOML class comment');
return undefined;
}
}
detectFramework(sourceCode) {
try {
if (sourceCode.includes('[package]') &&
(sourceCode.includes('[dependencies]') || sourceCode.includes('version ='))) {
return 'cargo';
}
if (sourceCode.includes('[tool.poetry]') ||
sourceCode.includes('poetry.dependencies')) {
return 'poetry';
}
if (sourceCode.includes('[project]') &&
sourceCode.includes('[build-system]')) {
return 'pep621';
}
if (sourceCode.includes('[deno]') ||
sourceCode.includes('deno.json')) {
return 'deno';
}
return null;
}
catch (error) {
logger.warn({ err: error }, 'Error detecting TOML framework');
return null;
}
}
}