Framework Detection Skill

This skill enables automatic detection of the Solidity development framework being used in a project and adapts workflows accordingly.

When to Use

Use this skill at the beginning of any Solidity development workflow to:

• Detect which framework is configured (Foundry, Hardhat, or Hybrid)
• Determine which commands to use for compilation, testing, deployment
• Adapt agent behavior to framework-specific patterns
• Handle hybrid setups where both frameworks coexist

Detection Logic

1. Foundry Detection

Check for foundry.toml in the project root:

# Foundry indicator
if [ -f "foundry.toml" ]; then
    echo "Foundry detected"
fi

Foundry-specific files:

• foundry.toml - Main configuration file
• lib/ directory - Dependencies (via git submodules)
• test/ directory with .t.sol files
• script/ directory for deployment scripts

Commands:

• Compile: forge build
• Test: forge test
• Deploy: forge script
• Coverage: forge coverage

2. Hardhat Detection

Check for hardhat.config.js or hardhat.config.ts in the project root:

# Hardhat indicator
if [ -f "hardhat.config.js" ] || [ -f "hardhat.config.ts" ]; then
    echo "Hardhat detected"
fi

Hardhat-specific files:

• hardhat.config.js or hardhat.config.ts - Main configuration
• package.json with hardhat dependencies
• node_modules/ directory
• test/ directory with .js or .ts files
• scripts/ directory for deployment

Commands:

• Compile: npx hardhat compile
• Test: npx hardhat test
• Deploy: npx hardhat run scripts/deploy.js
• Coverage: npx hardhat coverage

3. Hybrid Setup Detection

Both frameworks can coexist in the same project:

# Hybrid indicator
if [ -f "foundry.toml" ] && ([ -f "hardhat.config.js" ] || [ -f "hardhat.config.ts" ]); then
    echo "Hybrid setup detected"
fi

Hybrid workflow strategy:

• Primary: Use Foundry for compilation and testing (faster)
• Secondary: Use Hardhat for deployment and verification (better tooling)
• Flexibility: Allow agents to choose based on task requirements

Framework-Specific Workflow Adaptation

Compilation

# Foundry
forge build

# Hardhat
npx hardhat compile

# Hybrid (prefer Foundry)
forge build

Testing

# Foundry
forge test
forge test -vvv              # Verbose
forge test --match-test testName

# Hardhat
npx hardhat test
npx hardhat test --grep "pattern"

# Hybrid
forge test                    # Fast unit tests
npx hardhat test             # Integration tests with JS tooling

Deployment

# Foundry
forge script script/Deploy.s.sol:DeployScript --rpc-url $RPC_URL --broadcast

# Hardhat
npx hardhat run scripts/deploy.js --network mainnet

# Hybrid (prefer Hardhat for deployment)
npx hardhat run scripts/deploy.js --network mainnet

Gas Reporting

# Foundry
forge test --gas-report

# Hardhat
REPORT_GAS=true npx hardhat test

# Hybrid
forge test --gas-report      # More detailed

Coverage

# Foundry
forge coverage
forge coverage --report lcov

# Hardhat
npx hardhat coverage

# Hybrid (prefer Foundry)
forge coverage --report lcov

Agent Integration

All agents should call this skill first before executing any framework-specific commands:

**Framework Detection Process:**

1. Check for foundry.toml → Foundry detected
2. Check for hardhat.config.js/ts → Hardhat detected
3. Both present → Hybrid detected
4. Neither present → Prompt user or initialize

Example Agent Workflow

**Step 1: Detect Framework**

I'll first check which framework is configured in this project.

[Uses Bash tool to check for foundry.toml and hardhat.config.*]

**Framework detected:** Foundry

**Step 2: Adapt Commands**

Based on Foundry detection, I'll use:
- Compilation: `forge build`
- Testing: `forge test`
- Coverage: `forge coverage`

[Proceeds with Foundry-specific workflow...]

Hybrid Setup Recommendations

When both frameworks are detected, follow these guidelines:

Foundry Strengths

• Fast compilation (Rust-based)
• Fast testing (no JS overhead)
• Fuzz testing (built-in)
• Gas optimization (detailed reports)
• Formal verification (via Forge)

Use Foundry for:

• Unit testing
• Gas optimization
• Fuzz testing
• Development iteration (compile/test cycles)

Hardhat Strengths

• JavaScript ecosystem integration
• Better deployment tooling (scripts, tasks)
• Contract verification (Etherscan, etc.)
• Mature plugin ecosystem
• TypeScript support

Use Hardhat for:

• Deployment scripts
• Contract verification
• Integration with frontend
• Complex deployment workflows
• Network forking

Error Handling

No Framework Detected

If neither framework is detected:

⚠️ **No Solidity framework detected**

I couldn't find foundry.toml or hardhat.config.js/ts in this project.

Would you like to:
1. Initialize Foundry (`forge init`)
2. Initialize Hardhat (`npx hardhat init`)
3. Skip framework setup (manual configuration)

Framework Mismatch

If commands fail due to wrong framework assumptions:

⚠️ **Framework mismatch detected**

The command failed. Let me re-check the framework configuration and adapt.

[Re-runs framework detection]

Switching to [detected framework] workflow...

Best Practices

1. Always detect first - Never assume framework without checking
2. Adapt commands - Use framework-specific commands based on detection
3. Prefer Foundry for speed - In hybrid setups, use Foundry for dev tasks
4. Prefer Hardhat for deployment - Use Hardhat for production deployment
5. Be explicit - Tell the user which framework is being used
6. Handle errors gracefully - Re-detect if commands fail

Integration with Other Skills

This skill is foundational and should be referenced by:

• foundry-setup skill
• hardhat-setup skill
• All development agents (developer, tester, gas-optimizer, etc.)
• All testing workflows
• All deployment workflows

Quick Reference

Task	Foundry	Hardhat	Hybrid Strategy
Compile	forge build	npx hardhat compile	Use Foundry
Test	forge test	npx hardhat test	Use Foundry
Coverage	forge coverage	npx hardhat coverage	Use Foundry
Deploy	forge script	npx hardhat run	Use Hardhat
Verify	forge verify-contract	npx hardhat verify	Use Hardhat
Gas Report	forge test --gas-report	REPORT_GAS=true npx hardhat test	Use Foundry

---

Remember: Framework detection is the first step in any Solidity workflow. Always detect before executing commands.