What is framework-detector?

The Framework Detector is a sophisticated Claude skill designed to automate project environment analysis through multi-signal detection. By evaluating package managers, file structures, and code imports with a weighted confidence scoring system, it accurately identifies major frameworks such as React, NestJS, Rails, and .NET. This tool is essential for optimizing agentic workflows, allowing AI assistants to intelligently load framework-specific context and specialized tools for more accurate code generation and debugging.

When should I use framework-detector?

framework-detector is useful in the following scenarios: • Automated Skill Orchestration: Enable AI agents to dynamically detect a project's framework and automatically load the corresponding specialized coding skills without manual user input. • Project Onboarding & Auditing: Quickly analyze unfamiliar or legacy codebases to determine the core technology stack, dependencies, and architectural patterns. • Monorepo Management: Identify multiple distinct frameworks within a single repository to ensure that the correct development tools and context are applied to specific sub-directories. • CI/CD Pipeline Integration: Use the CLI interface to validate project structures or trigger framework-specific build and testing workflows based on automated detection results.

name	Framework Detector
version	1.0.0
min	1.0.0
recommended	1.0.0
backend-developer	">=3.0.0"
frontend-developer	">=3.0.0"
tech-lead-orchestrator	">=2.5.0"
description	Multi-signal framework detection with confidence scoring for 6 major frameworks
category	utility
updated	2025-10-22

Framework Detector Skill

Quick Reference

When to Use: Automatically detect framework in project before loading framework-specific skills

Supported Frameworks: NestJS, React, Phoenix, Rails, .NET/ASP.NET Core, Blazor

Detection Method: Multi-signal analysis with weighted confidence scoring

Usage

Basic Detection

const FrameworkDetector = require('./detect-framework');

const detector = new FrameworkDetector('/path/to/project');
const result = await detector.detect();

console.log(result.primary);    // "nestjs"
console.log(result.confidence); // 0.92
console.log(result.alternates); // [{ framework: "dotnet", confidence: 0.45 }]

CLI Usage

# Detect framework in current directory
./detect-framework.js

# Detect framework in specific project
./detect-framework.js /path/to/project

# Output format (JSON)
{
  "primary": "react",
  "confidence": 0.89,
  "alternates": [],
  "details": { ... }
}

Detection Signals

1. Package Manager (Weight: 10)

Node.js: package.json dependencies
Ruby: Gemfile gems
Elixir: mix.exs dependencies
.NET: *.csproj PackageReferences

2. Files (Weight: 8-9)

Required: Framework-specific config files
Optional: Common project structure files
Wildcards: Pattern matching (e.g., *.csproj)

3. Imports (Weight: 7-8)

Code pattern analysis in source files
Regex-based matching
File sampling for performance (max 20 files)

4. Boost Factors (Multiplier: 1.2-1.6x)

Strong indicators multiply confidence
Framework-specific patterns
Examples:
- NestJS: nest-cli.json (+50%)
- React: JSX files (+40%)
- Blazor: .razor files (+60%)

Confidence Threshold

Default: 0.8 (80% confidence required)

Interpretation:

≥ 0.9: Very high confidence
0.8-0.9: High confidence
0.6-0.8: Medium confidence (below threshold)
< 0.6: Low confidence

Framework-Specific Patterns

NestJS Detection

✓ @nestjs/core in package.json
✓ nest-cli.json exists
✓ @Module decorator in .ts files
✓ @Controller decorator in .ts files

React Detection

✓ react in package.json
✓ .jsx or .tsx files exist
✓ useState or useEffect in code
✓ createRoot in code

Phoenix Detection

✓ {:phoenix, in mix.exs
✓ config/config.exs exists
✓ Phoenix.Endpoint in .ex files
✓ Phoenix.Router in .ex files

Rails Detection

✓ gem 'rails' in Gemfile
✓ config/application.rb exists
✓ Rails.application in code
✓ ActiveRecord::Base in code

.NET Detection

✓ Microsoft.AspNetCore in .csproj
✓ Program.cs exists
✓ [ApiController] in .cs files
✓ using Microsoft.AspNetCore

Blazor Detection

✓ Microsoft.AspNetCore.Components in .csproj
✓ .razor files exist
✓ @page directive in .razor files
✓ ComponentBase in code

Performance

Optimizations:

File sampling (10-20 files max per check)
Glob ignore patterns (node_modules, dist, build)
Early exit on strong matches
Async/await for parallel checks

Typical Detection Time: 100-500ms

Error Handling

No Frameworks Detected:

{
  primary: null,
  confidence: 0,
  alternates: [],
  details: {}
}

Multiple Frameworks (e.g., monorepo):

{
  primary: "react",
  confidence: 0.91,
  alternates: [
    { framework: "nestjs", confidence: 0.87 }
  ]
}

Integration with SkillLoader

const { SkillLoader } = require('../skill-loader');
const FrameworkDetector = require('./detect-framework');

async function loadFrameworkSkill(projectRoot) {
  // 1. Detect framework
  const detector = new FrameworkDetector(projectRoot);
  const result = await detector.detect();

  // 2. Handle low confidence
  if (result.confidence < 0.8) {
    // Prompt user or use alternates
    console.warn('Low confidence detection');
  }

  // 3. Load skill
  const loader = new SkillLoader({
    agentName: 'backend-developer',
    agentVersion: '3.0.0'
  });

  const skill = await loader.loadSkill(result.primary, 'quick');
  return skill;
}

Configuration

Edit framework-patterns.json to:

Add new frameworks
Adjust detection weights
Modify confidence threshold
Update boost factors

framework-detector

When & Why to Use This Skill

Use Cases