Moai Core Language Detection

Detection Priority:

1. Config file exists (highest accuracy)
2. Dependency analysis (framework identification)
3. File extension scan (fallback)

Level 2: Practical Implementation

Pattern 1: Node.js Project Detection - package.json

Objective: Identify JavaScript/TypeScript projects and extract metadata.

package.json Structure:

{
  "name": "my-web-app",
  "version": "1.0.0",
  "description": "Modern web application",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "test": "vitest",
    "lint": "eslint ."
  },
  "dependencies": {
    "react": "^18.2.0",
    "next": "14.0.0",
    "express": "^4.18.2"
  },
  "devDependencies": {
    "typescript": "^5.3.0",
    "vite": "^5.0.0",
    "vitest": "^1.0.0",
    "eslint": "^8.54.0"
  },
  "engines": {
    "node": ">=18.0.0",
    "npm": ">=9.0.0"
  }
}

Detection Logic:

• Language: JavaScript (default if no "type": "module")
• Language: TypeScript (devDependencies.typescript exists)
• Frameworks: React + Next.js (dependencies.react && dependencies.next)
• Server: Express (dependencies.express)
• Build Tool: Vite (devDependencies.vite)
• Test Framework: Vitest (devDependencies.vitest)
• Node Version: ≥18.0.0 (engines.node)

Implementation:

def detect_nodejs_project():
    """Detect Node.js project details from package.json."""
    
    # Check for package.json
    if not os.path.exists('package.json'):
        return None
    
    with open('package.json', 'r') as f:
        package_data = json.load(f)
    
    detection = {
        'language': 'javascript',
        'frameworks': [],
        'build_tools': [],
        'test_frameworks': [],
        'package_manager': 'npm',
        'node_version': None
    }
    
    # Language detection
    if package_data.get('type') == 'module':
        detection['language'] = 'javascript-esm'
    elif 'typescript' in package_data.get('devDependencies', {}):
        detection['language'] = 'typescript'
    
    # Framework detection
    deps = package_data.get('dependencies', {})
    if 'react' in deps:
        detection['frameworks'].append('react')
        if 'next' in deps:
            detection['frameworks'].append('next.js')
        elif 'gatsby' in deps:
            detection['frameworks'].append('gatsby')
    elif 'express' in deps:
        detection['frameworks'].append('express')
    elif 'vue' in deps:
        detection['frameworks'].append('vue')
    
    # Build tool detection
    dev_deps = package_data.get('devDependencies', {})
    if 'vite' in dev_deps:
        detection['build_tools'].append('vite')
    elif 'webpack' in dev_deps:
        detection['build_tools'].append('webpack')
    elif 'rollup' in dev_deps:
        detection['build_tools'].append('rollup')
    
    # Test framework detection
    if 'vitest' in dev_deps:
        detection['test_frameworks'].append('vitest')
    elif 'jest' in dev_deps:
        detection['test_frameworks'].append('jest')
    elif 'mocha' in dev_deps:
        detection['test_frameworks'].append('mocha')
    
    # Package manager detection
    if os.path.exists('pnpm-lock.yaml'):
        detection['package_manager'] = 'pnpm'
    elif os.path.exists('yarn.lock'):
        detection['package_manager'] = 'yarn'
    
    # Node version extraction
    engines = package_data.get('engines', {})
    detection['node_version'] = engines.get('node')
    
    return detection

Pattern 2: Python Project Detection - pyproject.toml

Objective: Identify Python projects and extract build system, framework, and dependency information.

pyproject.toml Structure:

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "my-python-app"
version = "1.0.0"
description = "Python application with FastAPI"
dependencies = [
    "fastapi>=0.104.0",
    "uvicorn[standard]>=0.24.0",
    "sqlalchemy>=2.0.0"
]

[project.optional-dependencies]
dev = [
    "pytest>=7.4.0",
    "pytest-cov>=4.1.0",
    "black>=23.0.0",
    "mypy>=1.7.0"
]

[tool.poetry]
name = "my-python-app"
version = "1.0.0"
description = "Python application with FastAPI"

[tool.poetry.dependencies]
python = "^3.11"
fastapi = "^0.104.0"
uvicorn = {extras = ["standard"], version = "^0.24.0"}

[tool.poetry.group.dev.dependencies]
pytest = "^7.4.0"
pytest-cov = "^4.1.0"
black = "^23.0.0"
mypy = "^1.7.0"

[tool.setuptools.packages.find]
where = ["src"]

[tool.black]
line-length = 88
target-version = ['py311']

[tool.mypy]
python_version = "3.11"
strict = true

Detection Logic:

• Build System: Poetry (tool.poetry), setuptools (build-system.requires), or pip (fallback)
• Python Version: From poetry.dependencies.python or requires-python
• Frameworks: FastAPI, Django, Flask (from dependencies)
• Test Frameworks: pytest, unittest (from optional-dependencies/dev)
• Linting: black, flake8, mypy (from dev dependencies)

Implementation:

def detect_python_project():
    """Detect Python project details from pyproject.toml."""
    
    # Check for pyproject.toml
    if not os.path.exists('pyproject.toml'):
        return None
    
    with open('pyproject.toml', 'r') as f:
        toml_data = toml.load(f)
    
    detection = {
        'language': 'python',
        'frameworks': [],
        'build_system': None,
        'test_frameworks': [],
        'linting_tools': [],
        'python_version': None,
        'package_manager': 'pip'
    }
    
    # Build system detection
    if 'tool' in toml_data and 'poetry' in toml_data['tool']:
        detection['build_system'] = 'poetry'
        detection['package_manager'] = 'poetry'
        
        # Extract Python version from Poetry
        python_dep = toml_data['tool']['poetry'].get('dependencies', {}).get('python')
        if python_dep:
            detection['python_version'] = python_dep.replace('^', '>=')
    elif 'build-system' in toml_data:
        build_requires = toml_data['build-system'].get('requires', [])
        if 'setuptools' in str(build_requires):
            detection['build_system'] = 'setuptools'
        elif 'flit' in str(build_requires):
            detection['build_system'] = 'flit'
        elif 'hatch' in str(build_requires):
            detection['build_system'] = 'hatch'
    
    # Framework detection from dependencies
    deps = []
    if 'project' in toml_data and 'dependencies' in toml_data['project']:
        deps = toml_data['project']['dependencies']
    elif 'tool' in toml_data and 'poetry' in toml_data['tool']:
        deps = list(toml_data['tool']['poetry'].get('dependencies', {}).keys())
    
    deps_str = ' '.join(deps).lower()
    if 'fastapi' in deps_str:
        detection['frameworks'].append('fastapi')
    if 'django' in deps_str:
        detection['frameworks'].append('django')
    if 'flask' in deps_str:
        detection['frameworks'].append('flask')
    if 'pydantic' in deps_str:
        detection['frameworks'].append('pydantic')
    
    # Test framework detection
    dev_deps = []
    if 'project' in toml_data and 'optional-dependencies' in toml_data['project']:
        dev_deps = toml_data['project']['optional-dependencies'].get('dev', [])
    elif 'tool' in toml_data and 'poetry' in toml_data:
        dev_deps = list(toml_data['tool']['poetry'].get('group', {}).get('dev', {}).get('dependencies', {}).keys())
    
    dev_deps_str = ' '.join(dev_deps).lower()
    if 'pytest' in dev_deps_str:
        detection['test_frameworks'].append('pytest')
    if 'unittest' in dev_deps_str:
        detection['test_frameworks'].append('unittest')
    
    # Linting tools detection
    if 'black' in dev_deps_str:
        detection['linting_tools'].append('black')
    if 'flake8' in dev_deps_str:
        detection['linting_tools'].append('flake8')
    if 'mypy' in dev_deps_str:
        detection['linting_tools'].append('mypy')
    if 'ruff' in dev_deps_str:
        detection['linting_tools'].append('ruff')
    
    return detection

Pattern 3: Rust Project Detection - Cargo.toml

Objective: Identify Rust projects and extract crate information, dependencies, and edition.

Cargo.toml Structure:

[package]
name = "my-rust-app"
version = "0.1.0"
edition = "2021"
description = "Rust application with web framework"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
axum = "0.7"
sqlx = { version = "0.7", features = ["postgres", "runtime-tokio-rustls"] }

[dev-dependencies]
tokio-test = "0.4"
criterion = "0.5"

[features]
default = ["axum"]
rocket = ["dep:rocket", "tokio/sync"]

[workspace]
members = [
    "crates/core",
    "crates/utils",
    "crates/api"
]

[profile.release]
lto = true
codegen-units = 1
panic = "abort"

Detection Logic:

• Edition: 2021, 2021, or 2018 from package.edition
• Frameworks: axum, rocket, actix-web (from dependencies)
• Async Runtime: tokio, async-std (from dependencies)
• Database: sqlx, diesel (from dependencies)
• Serialization: serde, serde_json (from dependencies)
• Workspace: Multi-crate project if workspace members exist

Implementation:

def detect_rust_project():
    """Detect Rust project details from Cargo.toml."""
    
    # Check for Cargo.toml
    if not os.path.exists('Cargo.toml'):
        return None
    
    with open('Cargo.toml', 'r') as f:
        cargo_data = toml.load(f)
    
    detection = {
        'language': 'rust',
        'frameworks': [],
        'async_runtime': None,
        'database_libs': [],
        'serialization': [],
        'edition': '2021',
        'is_workspace': False
    }
    
    # Package information
    if 'package' in cargo_data:
        package_info = cargo_data['package']
        detection['edition'] = package_info.get('edition', '2021')
    
    # Workspace detection
    if 'workspace' in cargo_data:
        detection['is_workspace'] = True
    
    # Dependencies analysis
    deps = cargo_data.get('dependencies', {})
    deps_str = ' '.join(deps.keys()).lower()
    
    # Framework detection
    if 'axum' in deps_str:
        detection['frameworks'].append('axum')
    if 'rocket' in deps_str:
        detection['frameworks'].append('rocket')
    if 'actix-web' in deps_str or 'actix' in deps_str:
        detection['frameworks'].append('actix-web')
    
    # Async runtime detection
    if 'tokio' in deps_str:
        detection['async_runtime'] = 'tokio'
    elif 'async-std' in deps_str:
        detection['async_runtime'] = 'async-std'
    
    # Database libraries detection
    if 'sqlx' in deps_str:
        detection['database_libs'].append('sqlx')
    if 'diesel' in deps_str:
        detection['database_libs'].append('diesel')
    if 'sea-orm' in deps_str:
        detection['database_libs'].append('sea-orm')
    
    # Serialization detection
    if 'serde' in deps_str:
        detection['serialization'].append('serde')
    if 'serde_json' in deps_str:
        detection['serialization'].append('serde_json')
    
    return detection

Pattern 4: Go Project Detection - go.mod

Objective: Identify Go projects and extract module information, Go version, and dependencies.

go.mod Structure:

module github.com/username/my-go-app

go 1.21

require (
    github.com/gin-gonic/gin 
    github.com/golang-migrate/migrate/v4 
    github.com/lib/pq 
    github.com/spf13/viper 
    github.com/stretchr/testify 
)

require (
    github.com/bytedance/sonic  // indirect
    github.com/chenzhuoyu/base64x -20221115062448-fe3a3abad311 // indirect
    github.com/gabriel-vasile/mimetype  // indirect
)

Detection Logic:

• Go Version: From go directive (1.21, 1.20, etc.)
• Frameworks: gin, echo, fiber (from require statements)
• Database: lib/pq (PostgreSQL), go-sqlite3, gorm (from require)
• Configuration: viper, envconfig (from require)
• Testing: testify, gomock (from require)

Implementation:

def detect_go_project():
    """Detect Go project details from go.mod."""
    
    # Check for go.mod
    if not os.path.exists('go.mod'):
        return None
    
    with open('go.mod', 'r') as f:
        go_mod_content = f.read()
    
    detection = {
        'language': 'go',
        'frameworks': [],
        'database_libs': [],
        'config_libs': [],
        'test_libs': [],
        'go_version': None,
        'module_name': None
    }
    
    lines = go_mod_content.split('\n')
    
    for line in lines: