Skip to main content Home Creators 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.
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-alfred-language-detectionThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... 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:
More from this repository
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).
Related occupations SOC
Based on SOC occupation classification
