ajbcoding/claude-skill-eval/moai-alfred-language-detection

Trust tier 3
  • community
Source check pending

Checking that the SKILL.md file is still in the repository.

Auto-detects project language and framework from package.json, pyproject.toml, Cargo.toml, go.mod, and other configuration files with comprehensive pattern matching based on 17,253+ production code examples.

Install

npx vskill@latest install ajbcoding/claude-skill-eval/moai-alfred-language-detection

SKILL.md

moai-alfred-language-detection

Enterprise Language & Framework Auto-Detection

Research Base: 17,253 code examples from 4 package managers
Version: 4.0.0

📖 Progressive Disclosure

Level 1: Quick Reference

Alfred automatically detects project language and framework by parsing configuration files:

Supported Languages (4 ecosystems):

  • JavaScript/TypeScript: package.json → npm/yarn/pnpm
  • Python: pyproject.toml → Poetry/pip/Pipenv
  • Rust: Cargo.toml → Cargo
  • Go: go.mod → Go modules

Key Capabilities:

  • Config file identification with priority order
  • Package manager detection via lockfiles
  • Framework identification from dependencies
  • Runtime version extraction
  • Monorepo pattern recognition
  • Fallback to extension analysis

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:

json
{
  "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:

python
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:

toml
[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:

python
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:

toml
[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:

python
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

This is the start of the file. Read the full SKILL.md on GitHub.

Security

  • Security scanPassed, 98 of 100Pattern checks on the skill's files.
  • Model reviewPassed

See the full security report

Quality evaluation

  • Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

Popularity

Repository stars
4
7-day trend score
8

Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 4 Apr 2026, 6 months ago.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/ajbcoding/claude-skill-eval/moai-alfred-language-detection/badge)](https://verified-skill.com/skills/ajbcoding/claude-skill-eval/moai-alfred-language-detection)

Something wrong with this skill or its page? Tell us.