Core Concepts

Multi-Language Support

Learn about AI Developer Assistant's multi-language support and language detection

Multi-Language Support

AI Developer Assistant provides comprehensive multi-language support with automatic language detection, framework selection, and tailored analysis for different programming languages. This guide covers all supported languages and their specific features.

Automatic Language Detection

AI Developer Assistant automatically detects programming languages from file extensions and provides tailored analysis:

Supported Languages

Language	File Extensions	Test Framework	Documentation Style	Security Focus
Dart	`.dart`	Flutter Test	Flutter-specific	Flutter security patterns
TypeScript	`.ts`, `.tsx`	Jest	TypeScript/JSDoc	Node.js security
JavaScript	`.js`, `.jsx`	Jest	JSDoc	Web security
Python	`.py`	pytest	Python docstrings	Python security
Java	`.java`	JUnit	JavaDoc	Enterprise security
C#	`.cs`	NUnit	XML Documentation	.NET security
Go	`.go`	Go Testing	Go Documentation	Go security
Rust	`.rs`	Cargo Test	Rust Documentation	Memory safety
PHP	`.php`	PHPUnit	PHPDoc	Web security
Ruby	`.rb`	RSpec	RDoc	Ruby security
Swift	`.swift`	XCTest	Swift Documentation	iOS security
Kotlin	`.kt`	JUnit	KDoc	Android security

Language-Specific Features

Dart/Flutter

# Review Flutter code
ai-dev review --file-patterns "lib/**/*.dart"

# Generate Flutter tests
ai-dev test-suggest --file-patterns "lib/**/*.dart"

# Flutter-specific security scan
ai-dev security-scan --file-patterns "lib/**/*.dart"

Flutter-Specific Analysis:

Widget testing patterns and best practices
State management (Provider, Bloc, Riverpod)
Performance optimization for mobile apps
Flutter security patterns and vulnerabilities
Platform-specific code analysis

Example Flutter Test Generation:

import 'package:flutter_test/flutter_test.dart';
import 'package:your_app/widgets/custom_button.dart';

void main() {
  group('CustomButton', () {
    testWidgets('should display button with correct text', (WidgetTester tester) async {
      await tester.pumpWidget(
        MaterialApp(
          home: CustomButton(
            text: 'Test Button',
            onPressed: () {},
          ),
        ),
      );

      expect(find.text('Test Button'), findsOneWidget);
    });

    testWidgets('should call onPressed when tapped', (WidgetTester tester) async {
      bool wasPressed = false;
      
      await tester.pumpWidget(
        MaterialApp(
          home: CustomButton(
            text: 'Test Button',
            onPressed: () => wasPressed = true,
          ),
        ),
      );

      await tester.tap(find.byType(CustomButton));
      expect(wasPressed, isTrue);
    });
  });
}

TypeScript/JavaScript

# Review TypeScript code
ai-dev review --file-patterns "src/**/*.ts"

# Generate Jest tests
ai-dev test-suggest --file-patterns "src/**/*.ts"

# Node.js security scan
ai-dev security-scan --file-patterns "src/**/*.ts"

TypeScript/JavaScript-Specific Analysis:

ES6+ features and modern JavaScript patterns
Type safety and TypeScript best practices
Async/await patterns and Promise handling
Node.js security vulnerabilities
Web security (XSS, CSRF, etc.)

Example Jest Test Generation:

import { calculateTotal, validateInput } from '../utils/helper';

describe('Helper Functions', () => {
  describe('calculateTotal', () => {
    it('should calculate total correctly for valid items', () => {
      const items = [
        { price: 10, quantity: 2 },
        { price: 5, quantity: 3 }
      ];
      
      const total = calculateTotal(items);
      expect(total).toBe(35);
    });

    it('should handle empty array', () => {
      const total = calculateTotal([]);
      expect(total).toBe(0);
    });

    it('should throw error for invalid items', () => {
      expect(() => calculateTotal(null)).toThrow('Items must be an array');
    });
  });

  describe('validateInput', () => {
    it('should validate email format', () => {
      expect(validateInput('test@example.com', 'email')).toBe(true);
      expect(validateInput('invalid-email', 'email')).toBe(false);
    });
  });
});

Python

# Review Python code
ai-dev review --file-patterns "**/*.py"

# Generate pytest tests
ai-dev test-suggest --file-patterns "**/*.py"

# Python security scan
ai-dev security-scan --file-patterns "**/*.py"

Python-Specific Analysis:

PEP 8 compliance and Python style guide
Type hints and modern Python features
Async patterns (asyncio, async/await)
Python security vulnerabilities
Django/Flask framework patterns

Example pytest Test Generation:

import pytest
from src.utils.helper import calculate_total, validate_email

class TestHelperFunctions:
    def test_calculate_total_valid_items(self):
        items = [
            {'price': 10, 'quantity': 2},
            {'price': 5, 'quantity': 3}
        ]
        
        total = calculate_total(items)
        assert total == 35

    def test_calculate_total_empty_list(self):
        total = calculate_total([])
        assert total == 0

    def test_calculate_total_invalid_input(self):
        with pytest.raises(ValueError, match="Items must be a list"):
            calculate_total(None)

    def test_validate_email_valid(self):
        assert validate_email('test@example.com') is True

    def test_validate_email_invalid(self):
        assert validate_email('invalid-email') is False

    @pytest.mark.parametrize("email,expected", [
        ('test@example.com', True),
        ('user.name@domain.co.uk', True),
        ('invalid-email', False),
        ('@domain.com', False),
    ])
    def test_validate_email_parametrized(self, email, expected):
        assert validate_email(email) == expected

Java

# Review Java code
ai-dev review --file-patterns "src/**/*.java"

# Generate JUnit tests
ai-dev test-suggest --file-patterns "src/**/*.java"

# Java security scan
ai-dev security-scan --file-patterns "src/**/*.java"

Java-Specific Analysis:

Spring framework patterns and best practices
JVM performance optimization
Enterprise patterns and design principles
Java security vulnerabilities
Maven/Gradle dependency management

Example JUnit Test Generation:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;

class UserServiceTest {
    private UserService userService;
    private UserRepository userRepository;

    @BeforeEach
    void setUp() {
        userRepository = mock(UserRepository.class);
        userService = new UserService(userRepository);
    }

    @Test
    @DisplayName("Should create user successfully")
    void shouldCreateUserSuccessfully() {
        // Given
        User user = new User("john.doe", "john@example.com");
        when(userRepository.save(any(User.class))).thenReturn(user);

        // When
        User result = userService.createUser(user);

        // Then
        assertNotNull(result);
        assertEquals("john.doe", result.getUsername());
        assertEquals("john@example.com", result.getEmail());
        verify(userRepository).save(user);
    }

    @Test
    @DisplayName("Should throw exception for invalid email")
    void shouldThrowExceptionForInvalidEmail() {
        // Given
        User user = new User("john.doe", "invalid-email");

        // When & Then
        assertThrows(IllegalArgumentException.class, () -> {
            userService.createUser(user);
        });
    }

    @ParameterizedTest
    @ValueSource(strings = {"test@example.com", "user@domain.co.uk", "admin@company.org"})
    @DisplayName("Should validate email formats")
    void shouldValidateEmailFormats(String email) {
        assertTrue(userService.isValidEmail(email));
    }
}

Go

# Review Go code
ai-dev review --file-patterns "**/*.go"

# Generate Go tests
ai-dev test-suggest --file-patterns "**/*.go"

# Go security scan
ai-dev security-scan --file-patterns "**/*.go"

Go-Specific Analysis:

Go idioms and best practices
Concurrency patterns (goroutines, channels)
Error handling conventions
Go security vulnerabilities
Performance optimization techniques

Example Go Test Generation:

package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

func TestCalculateTotal(t *testing.T) {
    tests := []struct {
        name     string
        items    []Item
        expected float64
    }{
        {
            name: "valid items",
            items: []Item{
                {Price: 10.0, Quantity: 2},
                {Price: 5.0, Quantity: 3},
            },
            expected: 35.0,
        },
        {
            name:     "empty items",
            items:    []Item{},
            expected: 0.0,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := CalculateTotal(tt.items)
            assert.Equal(t, tt.expected, result)
        })
    }
}

func TestValidateEmail(t *testing.T) {
    validEmails := []string{
        "test@example.com",
        "user.name@domain.co.uk",
        "admin@company.org",
    }

    for _, email := range validEmails {
        t.Run("valid_"+email, func(t *testing.T) {
            assert.True(t, ValidateEmail(email))
        })
    }

    invalidEmails := []string{
        "invalid-email",
        "@domain.com",
        "user@",
    }

    for _, email := range invalidEmails {
        t.Run("invalid_"+email, func(t *testing.T) {
            assert.False(t, ValidateEmail(email))
        })
    }
}

Rust

# Review Rust code
ai-dev review --file-patterns "src/**/*.rs"

# Generate Cargo tests
ai-dev test-suggest --file-patterns "src/**/*.rs"

# Rust security scan
ai-dev security-scan --file-patterns "src/**/*.rs"

Rust-Specific Analysis:

Ownership patterns and memory safety
Error handling with Result and Option
Performance optimization techniques
Rust security patterns
Cargo dependency management

Example Rust Test Generation:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_calculate_total_valid_items() {
        let items = vec![
            Item { price: 10.0, quantity: 2 },
            Item { price: 5.0, quantity: 3 },
        ];
        
        let total = calculate_total(&items);
        assert_eq!(total, 35.0);
    }

    #[test]
    fn test_calculate_total_empty_items() {
        let items = vec![];
        let total = calculate_total(&items);
        assert_eq!(total, 0.0);
    }

    #[test]
    fn test_validate_email_valid() {
        assert!(validate_email("test@example.com"));
        assert!(validate_email("user.name@domain.co.uk"));
    }

    #[test]
    fn test_validate_email_invalid() {
        assert!(!validate_email("invalid-email"));
        assert!(!validate_email("@domain.com"));
    }

    #[test]
    fn test_validate_email_edge_cases() {
        assert!(!validate_email(""));
        assert!(!validate_email("user@"));
    }
}

Framework Auto-Selection

Automatic Framework Detection

AI Developer Assistant automatically selects the most appropriate testing framework for each language:

# These commands automatically detect language and select framework
ai-dev test-suggest --file-patterns "lib/**/*.dart"     # → Flutter Test
ai-dev test-suggest --file-patterns "src/**/*.ts"      # → Jest
ai-dev test-suggest --file-patterns "tests/**/*.py"    # → pytest
ai-dev test-suggest --file-patterns "src/**/*.java"    # → JUnit
ai-dev test-suggest --file-patterns "src/**/*.go"      # → Go Testing
ai-dev test-suggest --file-patterns "src/**/*.rs"      # → Cargo Test

Override Framework Selection

You can override the automatic framework selection:

# Override automatic detection
ai-dev test-suggest --file-patterns "**/*.ts" --framework vitest

# Use specific framework
ai-dev test-suggest --file-patterns "**/*.py" --framework unittest

Language-Specific Security Patterns

Web Security (JavaScript/TypeScript)

# Web security focus
ai-dev security-scan --file-patterns "src/**/*.{ts,js}" --categories injection,authentication

Common Web Security Issues:

XSS vulnerabilities in user input handling
CSRF attacks in form submissions
SQL injection in database queries
Authentication bypass vulnerabilities
Session management issues

Mobile Security (Dart/Flutter)

# Mobile security focus
ai-dev security-scan --file-patterns "lib/**/*.dart" --categories authentication,data_exposure

Common Mobile Security Issues:

Insecure data storage in local databases
Network security in API communications
Authentication and session management
Data encryption for sensitive information
Platform-specific security vulnerabilities

Backend Security (Python/Java/Go)

# Backend security focus
ai-dev security-scan --file-patterns "src/**/*.py" --categories injection,authentication,authorization

Common Backend Security Issues:

API security and rate limiting
Database security and query protection
Authentication and authorization
Input validation and sanitization
Dependency vulnerabilities

Multi-Language Project Support

Mixed Language Projects

# Review multiple languages in one command
ai-dev review --file-patterns "frontend/**/*.{ts,tsx},backend/**/*.py,mobile/**/*.dart"

# Generate tests for different languages
ai-dev test-suggest --file-patterns "frontend/**/*.{ts,tsx}"  # Jest tests
ai-dev test-suggest --file-patterns "backend/**/*.py"        # pytest tests
ai-dev test-suggest --file-patterns "mobile/**/*.dart"       # Flutter tests

Language-Specific Configuration

# ai-dev.config.local.yaml
languageSettings:
  typescript:
    framework: "jest"
    testType: "unit"
    securityFocus: ["injection", "authentication"]
  
  python:
    framework: "pytest"
    testType: "unit"
    securityFocus: ["injection", "authentication", "authorization"]
  
  dart:
    framework: "flutter_test"
    testType: "widget"
    securityFocus: ["authentication", "data_exposure"]

Best Practices

1. Use Language-Specific Patterns

# Use appropriate file patterns for each language
ai-dev review --file-patterns "src/**/*.ts"           # TypeScript
ai-dev review --file-patterns "lib/**/*.dart"         # Dart/Flutter
ai-dev review --file-patterns "**/*.py"               # Python
ai-dev review --file-patterns "src/main/java/**/*.java" # Java

2. Leverage Framework Auto-Detection

# Let AI Developer Assistant choose the framework
ai-dev test-suggest --file-patterns "src/**/*.ts"     # Auto-detects Jest
ai-dev test-suggest --file-patterns "**/*.py"         # Auto-detects pytest

3. Focus on Language-Specific Security

# Use appropriate security categories for each language
ai-dev security-scan --file-patterns "src/**/*.ts" --categories injection,authentication  # Web security
ai-dev security-scan --file-patterns "lib/**/*.dart" --categories authentication,data_exposure  # Mobile security

4. Generate Language-Appropriate Documentation

# Generate documentation in the appropriate style
ai-dev docs --file-patterns "src/**/*.ts" --format jsdoc      # TypeScript
ai-dev docs --file-patterns "**/*.py" --format rst            # Python
ai-dev docs --file-patterns "src/**/*.java" --format javadoc  # Java

AI Developer Assistant's multi-language support is designed to work seamlessly with your existing codebase. The automatic language detection means you can use the same commands across different languages and get appropriate, language-specific analysis and suggestions.

Edit this pageorReport an issue

Customization & Extensibility

Learn how to customize and extend AI Developer Assistant for your specific needs

LLM Provider Configuration

Learn how to configure and use different LLM providers with AI Developer Assistant