Skip to main content Accueil Créateurs 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.
Aller à l'installation Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-alfred-language-detectionLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... 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).
Métiers associés SOC
Basé sur la classification professionnelle SOC
Explorateur de fichiers
3 fichiers 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:
