Skip to main content Inicio Creadores ajbcoding claude-skill-eval moai-alfred-language-detection
moai-alfred-language-detection 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.
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-alfred-language-detectionEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... Explorador de archivos
3 archivos Más de este repositorio Enterprise database architecture specialist with PostgreSQL 17, MySQL 8.4 LTS,
MongoDB 8.0, Redis 7.4 expertise. Master connection pooling, query optimization,
caching strategies, and database DevOps automation. Build scalable, resilient
database systems with comprehensive monitoring and disaster recovery.
Enterprise Frontend Development with AI-powered modern architecture, Context7 integration, and intelligent component orchestration for scalable user interfaces
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
name moai-alfred-language-detection version 4.0.0 created 2025-10-22 updated 2025-11-12 tier Alfred description 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. allowed-tools Read, Bash(rg:*), Bash(grep:*) primary-agent alfred secondary-agents ["plan-agent","implementation-planner"] keywords ["language-detection","framework-identification","package-manager","auto-detection","project-analysis","nodejs","python","rust","golang"] status stable
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/pnpmPython : pyproject.toml → Poetry/pip/PipenvRust : Cargo.toml → CargoGo : 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 :
Config file exists (highest accuracy)
Dependency analysis (framework identification)
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"
}
}
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) def detect_nodejs_project ():
"""Detect Node.js project details from 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
}
if package_data.get('type' ) == 'module' :
detection['language' ] = 'javascript-esm'
elif 'typescript' in package_data.get('devDependencies' , {}):
detection['language' ] = 'typescript'
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' )
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' )
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' )
if os.path.exists('pnpm-lock.yaml' ):
detection['package_manager' ] = 'pnpm'
elif os.path.exists('yarn.lock' ):
detection['package_manager' ] = 'yarn'
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
Build System : Poetry (tool.poetry), setuptools (build-system.requires), or pip (fallback)Python Version : From poetry.dependencies.python or requires-pythonFrameworks : FastAPI, Django, Flask (from dependencies)Test Frameworks : pytest, unittest (from optional-dependencies/dev)Linting : black, flake8, mypy (from dev dependencies) def detect_python_project ():
"""Detect Python project details from 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'
}
if 'tool' in toml_data and 'poetry' in toml_data['tool' ]:
detection['build_system' ] = 'poetry'
detection['package_manager' ] = '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'
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' )
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' )
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.
[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"
Edition : 2021, 2021, or 2018 from package.editionFrameworks : 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 def detect_rust_project ():
"""Detect Rust project details from 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
}
if 'package' in cargo_data:
package_info = cargo_data['package' ]
detection['edition' ] = package_info.get('edition' , '2021' )
if 'workspace' in cargo_data:
detection['is_workspace' ] = True
deps = cargo_data.get('dependencies' , {})
deps_str = ' ' .join(deps.keys()).lower()
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' )
if 'tokio' in deps_str:
detection['async_runtime' ] = 'tokio'
elif 'async-std' in deps_str:
detection['async_runtime' ] = 'async-std'
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' )
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.
module github.com/username/my-go -app
go 1.21
require (
github.com/gin-gonic/gin v1.9 .1
github.com/golang-migrate/migrate/v4 v4.16 .2
github.com/lib/pq v1.10 .9
github.com/spf13/viper v1.17 .0
github.com/stretchr/testify v1.8 .4
)
require (
github.com/bytedance/sonic v1.9 .1
github.com/chenzhuoyu/base64x v0.0 .0 -20221115062448 -fe3a3abad311
github.com/gabriel-vasile/mimetype v1.4 .2
)
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) def detect_go_project ():
"""Detect Go project details from 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:
