Framework Detection

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

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