Skip to main content Início Criadores 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 para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-alfred-language-detectionO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Mais deste repositório 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).
Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
Explorador de arquivos
3 arquivos 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:
