alirezarezvani
diff --git a/‎.codex/skills-index.json‎
Lines changed: 1 addition & 1 deletion b/‎.codex/skills-index.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎engineering-team/tdd-guide/SKILL.md‎
Lines changed: 88 additions & 257 deletions b/‎engineering-team/tdd-guide/SKILL.md‎
Lines changed: 88 additions & 257 deletions
diff --git a/‎…ring-team/tdd-guide/expected_output.json‎ ‎…am/tdd-guide/assets/expected_output.json‎engineering-team/tdd-guide/expected_output.json renamed to engineering-team/tdd-guide/assets/expected_output.json b/‎…ring-team/tdd-guide/expected_output.json‎ ‎…am/tdd-guide/assets/expected_output.json‎engineering-team/tdd-guide/expected_output.json renamed to engineering-team/tdd-guide/assets/expected_output.json
diff --git a/‎…am/tdd-guide/sample_coverage_report.lcov‎ ‎…guide/assets/sample_coverage_report.lcov‎engineering-team/tdd-guide/sample_coverage_report.lcov renamed to engineering-team/tdd-guide/assets/sample_coverage_report.lcov b/‎…am/tdd-guide/sample_coverage_report.lcov‎ ‎…guide/assets/sample_coverage_report.lcov‎engineering-team/tdd-guide/sample_coverage_report.lcov renamed to engineering-team/tdd-guide/assets/sample_coverage_report.lcov
diff --git a/‎…-team/tdd-guide/sample_input_python.json‎ ‎…dd-guide/assets/sample_input_python.json‎engineering-team/tdd-guide/sample_input_python.json renamed to engineering-team/tdd-guide/assets/sample_input_python.json b/‎…-team/tdd-guide/sample_input_python.json‎ ‎…dd-guide/assets/sample_input_python.json‎engineering-team/tdd-guide/sample_input_python.json renamed to engineering-team/tdd-guide/assets/sample_input_python.json
diff --git a/‎…m/tdd-guide/sample_input_typescript.json‎ ‎…uide/assets/sample_input_typescript.json‎engineering-team/tdd-guide/sample_input_typescript.json renamed to engineering-team/tdd-guide/assets/sample_input_typescript.json b/‎…m/tdd-guide/sample_input_typescript.json‎ ‎…uide/assets/sample_input_typescript.json‎engineering-team/tdd-guide/sample_input_typescript.json renamed to engineering-team/tdd-guide/assets/sample_input_typescript.json
@@ -117,7 +117,7 @@
       "name": "tdd-guide",
       "source": "../../engineering-team/tdd-guide",
       "category": "engineering",
-      "description": "Comprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation"
+      "description": "Test-driven development workflow with test generation, coverage analysis, and multi-framework support"
     },
     {
       "name": "tech-stack-evaluator",
 
@@ -1,287 +1,118 @@
 ---
 name: tdd-guide
-description: Comprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation
+description: Test-driven development workflow with test generation, coverage analysis, and multi-framework support
+triggers:
+  - generate tests
+  - analyze coverage
+  - TDD workflow
+  - red green refactor
+  - Jest tests
+  - Pytest tests
+  - JUnit tests
+  - coverage report
 ---
 
-# TDD Guide - Test Driven Development for Engineering Teams
+# TDD Guide
 
-A comprehensive Test Driven Development skill that provides intelligent test generation, coverage analysis, framework integration, and TDD workflow guidance across multiple languages and testing frameworks.
+Test-driven development skill for generating tests, analyzing coverage, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, and Vitest.
 
-## Capabilities
-
-### Test Generation
-- **Generate Test Cases from Requirements**: Convert user stories, API specs, and business requirements into executable test cases
-- **Create Test Stubs**: Generate test function scaffolding with proper naming, imports, and setup/teardown
-- **Generate Test Fixtures**: Create realistic test data, mocks, and fixtures for various scenarios
-
-### TDD Workflow Support
-- **Guide Red-Green-Refactor**: Step-by-step guidance through TDD cycles with validation
-- **Suggest Missing Scenarios**: Identify untested edge cases, error conditions, and boundary scenarios
-- **Review Test Quality**: Analyze test isolation, assertions quality, naming conventions, and maintainability
-
-### Coverage & Metrics Analysis
-- **Calculate Coverage**: Parse LCOV, JSON, and XML coverage reports for line/branch/function coverage
-- **Identify Untested Paths**: Find code paths, branches, and error handlers without test coverage
-- **Recommend Improvements**: Prioritized recommendations (P0/P1/P2) for coverage gaps and test quality
-
-### Framework Integration
-- **Multi-Framework Support**: Jest, Pytest, JUnit, Vitest, Mocha, RSpec adapters
-- **Generate Boilerplate**: Create test files with proper imports, describe blocks, and best practices
-- **Configure Test Runners**: Set up test configuration, coverage tools, and CI integration
-
-### Comprehensive Metrics
-- **Test Coverage**: Line, branch, function coverage with gap analysis
-- **Code Complexity**: Cyclomatic complexity, cognitive complexity, testability scoring
-- **Test Quality**: Assertions per test, isolation score, naming quality, test smell detection
-- **Test Data**: Boundary value analysis, edge case identification, mock data generation
-- **Test Execution**: Timing analysis, slow test detection, flakiness detection
-- **Missing Tests**: Uncovered edge cases, error handling gaps, missing integration scenarios
-
-## Input Requirements
-
-The skill supports **automatic format detection** for flexible input:
-
-### Source Code
-- **Languages**: TypeScript, JavaScript, Python, Java
-- **Format**: Direct file paths or copy-pasted code blocks
-- **Detection**: Automatic language/framework detection from syntax and imports
-
-### Test Artifacts
-- **Coverage Reports**: LCOV (.lcov), JSON (coverage-final.json), XML (cobertura.xml)
-- **Test Results**: JUnit XML, Jest JSON, Pytest JSON, TAP format
-- **Format**: File paths or raw coverage data
-
-### Requirements (Optional)
-- **User Stories**: Text descriptions of functionality
-- **API Specifications**: OpenAPI/Swagger, REST endpoints, GraphQL schemas
-- **Business Requirements**: Acceptance criteria, business rules
-
-### Input Methods
-- **Option A**: Provide file paths (skill will read files)
-- **Option B**: Copy-paste code/data directly
-- **Option C**: Mix of both (automatically detected)
-
-## Output Formats
-
-The skill provides **context-aware output** optimized for your environment:
-
-### Code Files
-- **Test Files**: Generated tests (Jest/Pytest/JUnit/Vitest) with proper structure
-- **Fixtures**: Test data files, mock objects, factory functions
-- **Mocks**: Mock implementations, stub functions, test doubles
-
-### Reports
-- **Markdown**: Rich coverage reports, recommendations, quality analysis (Claude Desktop)
-- **JSON**: Machine-readable metrics, structured data for CI/CD integration
-- **Terminal-Friendly**: Simplified output for Claude Code CLI
-
-### Smart Defaults
-- **Desktop/Apps**: Rich markdown with tables, code blocks, visual hierarchy
-- **CLI**: Concise, terminal-friendly format with clear sections
-- **CI/CD**: JSON output for automated processing
-
-### Progressive Disclosure
-- **Summary First**: High-level overview (<200 tokens)
-- **Details on Demand**: Full analysis available (500-1000 tokens)
-- **Prioritized**: P0 (critical) → P1 (important) → P2 (nice-to-have)
-
-## How to Use
-
-### Basic Usage
-```
-@tdd-guide
-
-I need tests for my authentication module. Here's the code:
-[paste code or provide file path]
-
-Generate comprehensive test cases covering happy path, error cases, and edge cases.
-```
-
-### Coverage Analysis
-```
-@tdd-guide
-
-Analyze test coverage for my TypeScript project. Coverage report: coverage/lcov.info
+## Table of Contents
 
-Identify gaps and provide prioritized recommendations.
-```
+- [Capabilities](#capabilities)
+- [Workflows](#workflows)
+- [Tools](#tools)
+- [Input Requirements](#input-requirements)
+- [Limitations](#limitations)
 
-### TDD Workflow
-```
-@tdd-guide
+---
 
-Guide me through TDD for implementing a password validation function.
+## Capabilities
 
-Requirements:
-- Min 8 characters
-- At least 1 uppercase, 1 lowercase, 1 number, 1 special char
-- No common passwords
-```
+| Capability | Description |
+|------------|-------------|
+| Test Generation | Convert requirements or code into test cases with proper structure |
+| Coverage Analysis | Parse LCOV/JSON/XML reports, identify gaps, prioritize fixes |
+| TDD Workflow | Guide red-green-refactor cycles with validation |
+| Framework Adapters | Generate tests for Jest, Pytest, JUnit, Vitest, Mocha |
+| Quality Scoring | Assess test isolation, assertions, naming, detect test smells |
+| Fixture Generation | Create realistic test data, mocks, and factories |
 
-### Multi-Framework Support
-```
-@tdd-guide
+---
 
-Convert these Jest tests to Pytest format:
-[paste Jest tests]
-```
+## Workflows
 
-## Scripts
+### Generate Tests from Code
 
-### Core Modules
+1. Provide source code (TypeScript, JavaScript, Python, Java)
+2. Specify target framework (Jest, Pytest, JUnit, Vitest)
+3. Run `test_generator.py` with requirements
+4. Review generated test stubs
+5. **Validation:** Tests compile and cover happy path, error cases, edge cases
 
-- **test_generator.py**: Intelligent test case generation from requirements and code
-- **coverage_analyzer.py**: Parse and analyze coverage reports (LCOV, JSON, XML)
-- **metrics_calculator.py**: Calculate comprehensive test and code quality metrics
-- **framework_adapter.py**: Multi-framework adapter (Jest, Pytest, JUnit, Vitest)
-- **tdd_workflow.py**: Red-green-refactor workflow guidance and validation
-- **fixture_generator.py**: Generate realistic test data and fixtures
-- **format_detector.py**: Automatic language and framework detection
+### Analyze Coverage Gaps
 
-### Utilities
+1. Generate coverage report from test runner (`npm test -- --coverage`)
+2. Run `coverage_analyzer.py` on LCOV/JSON/XML report
+3. Review prioritized gaps (P0/P1/P2)
+4. Generate missing tests for uncovered paths
+5. **Validation:** Coverage meets target threshold (typically 80%+)
 
-- **complexity_analyzer.py**: Cyclomatic and cognitive complexity analysis
-- **test_quality_scorer.py**: Test quality scoring (isolation, assertions, naming)
-- **missing_test_detector.py**: Identify untested paths and missing scenarios
-- **output_formatter.py**: Context-aware output formatting (Desktop vs CLI)
+### TDD New Feature
 
-## Best Practices
+1. Write failing test first (RED)
+2. Run `tdd_workflow.py --phase red` to validate
+3. Implement minimal code to pass (GREEN)
+4. Run `tdd_workflow.py --phase green` to validate
+5. Refactor while keeping tests green (REFACTOR)
+6. **Validation:** All tests pass after each cycle
 
-### Test Generation
-1. **Start with Requirements**: Write tests from user stories before seeing implementation
-2. **Test Behavior, Not Implementation**: Focus on what code does, not how it does it
-3. **One Assertion Focus**: Each test should verify one specific behavior
-4. **Descriptive Names**: Test names should read like specifications
+---
 
-### TDD Workflow
-1. **Red**: Write failing test first
-2. **Green**: Write minimal code to make it pass
-3. **Refactor**: Improve code while keeping tests green
-4. **Repeat**: Small iterations, frequent commits
+## Tools
 
-### Coverage Goals
-1. **Aim for 80%+**: Line coverage baseline for most projects
-2. **100% Critical Paths**: Authentication, payments, data validation must be fully covered
-3. **Branch Coverage Matters**: Line coverage alone is insufficient
-4. **Don't Game Metrics**: Focus on meaningful tests, not coverage numbers
+| Tool | Purpose | Usage |
+|------|---------|-------|
+| `test_generator.py` | Generate test cases from code/requirements | `python scripts/test_generator.py --input source.py --framework pytest` |
+| `coverage_analyzer.py` | Parse and analyze coverage reports | `python scripts/coverage_analyzer.py --report lcov.info --threshold 80` |
+| `tdd_workflow.py` | Guide red-green-refactor cycles | `python scripts/tdd_workflow.py --phase red --test test_auth.py` |
+| `framework_adapter.py` | Convert tests between frameworks | `python scripts/framework_adapter.py --from jest --to pytest` |
+| `fixture_generator.py` | Generate test data and mocks | `python scripts/fixture_generator.py --entity User --count 5` |
+| `metrics_calculator.py` | Calculate test quality metrics | `python scripts/metrics_calculator.py --tests tests/` |
+| `format_detector.py` | Detect language and framework | `python scripts/format_detector.py --file source.ts` |
+| `output_formatter.py` | Format output for CLI/desktop/CI | `python scripts/output_formatter.py --format markdown` |
 
-### Test Quality
-1. **Independent Tests**: Each test should run in isolation
-2. **Fast Execution**: Keep unit tests under 100ms each
-3. **Deterministic**: Tests should always produce same results
-4. **Clear Failures**: Assertion messages should explain what went wrong
+---
 
-### Framework Selection
-1. **Jest**: JavaScript/TypeScript projects (React, Node.js)
-2. **Pytest**: Python projects (Django, Flask, FastAPI)
-3. **JUnit**: Java projects (Spring, Android)
-4. **Vitest**: Modern Vite-based projects
+## Input Requirements
 
-## Multi-Language Support
+**For Test Generation:**
+- Source code (file path or pasted content)
+- Target framework (Jest, Pytest, JUnit, Vitest)
+- Coverage scope (unit, integration, edge cases)
 
-### TypeScript/JavaScript
-- Frameworks: Jest, Vitest, Mocha, Jasmine
-- Runners: Node.js, Karma, Playwright
-- Coverage: Istanbul/nyc, c8
+**For Coverage Analysis:**
+- Coverage report file (LCOV, JSON, or XML format)
+- Optional: Source code for context
+- Optional: Target threshold percentage
 
-### Python
-- Frameworks: Pytest, unittest, nose2
-- Runners: pytest, tox, nox
-- Coverage: coverage.py, pytest-cov
+**For TDD Workflow:**
+- Feature requirements or user story
+- Current phase (RED, GREEN, REFACTOR)
+- Test code and implementation status
 
-### Java
-- Frameworks: JUnit 5, TestNG, Mockito
-- Runners: Maven Surefire, Gradle Test
-- Coverage: JaCoCo, Cobertura
+---
 
 ## Limitations
 
-### Scope
-- **Unit Tests Focus**: Primarily optimized for unit tests (integration tests require different patterns)
-- **Static Analysis Only**: Cannot execute tests or measure actual code behavior
-- **Language Support**: Best support for TypeScript, JavaScript, Python, Java (other languages limited)
-
-### Coverage Analysis
-- **Report Dependency**: Requires existing coverage reports (cannot generate coverage from scratch)
-- **Format Support**: LCOV, JSON, XML only (other formats need conversion)
-- **Interpretation Context**: Coverage numbers need human judgment for meaningfulness
-
-### Test Generation
-- **Baseline Quality**: Generated tests provide scaffolding, require human review and refinement
-- **Complex Logic**: Advanced business logic and integration scenarios need manual test design
-- **Mocking Strategy**: Mock/stub strategies should align with project patterns
-
-### Framework Integration
-- **Configuration Required**: Test runners need proper setup (this skill doesn't modify package.json or pom.xml)
-- **Version Compatibility**: Generated code targets recent stable versions (Jest 29+, Pytest 7+, JUnit 5+)
-
-### When NOT to Use This Skill
-- **E2E Testing**: Use dedicated E2E tools (Playwright, Cypress, Selenium)
-- **Performance Testing**: Use JMeter, k6, or Locust
-- **Security Testing**: Use OWASP ZAP, Burp Suite, or security-focused tools
-- **Manual Testing**: Some scenarios require human exploratory testing
-
-## Example Workflows
-
-### Workflow 1: Generate Tests from Requirements
-```
-Input: User story + API specification
-Process: Parse requirements → Generate test cases → Create test stubs
-Output: Complete test files ready for implementation
-```
-
-### Workflow 2: Improve Coverage
-```
-Input: Coverage report + source code
-Process: Identify gaps → Suggest tests → Generate test code
-Output: Prioritized test cases for uncovered code
-```
-
-### Workflow 3: TDD New Feature
-```
-Input: Feature requirements
-Process: Guide red-green-refactor → Validate each step → Suggest refactorings
-Output: Well-tested feature with clean code
-```
-
-### Workflow 4: Framework Migration
-```
-Input: Tests in Framework A
-Process: Parse tests → Translate patterns → Generate equivalent tests
-Output: Tests in Framework B with same coverage
-```
-
-## Integration Points
-
-### CI/CD Integration
-- Parse coverage reports from CI artifacts
-- Generate coverage badges and reports
-- Fail builds on coverage thresholds
-- Track coverage trends over time
-
-### IDE Integration
-- Generate tests for selected code
-- Run coverage analysis on save
-- Highlight untested code paths
-- Quick-fix suggestions for test gaps
-
-### Code Review
-- Validate test coverage in PRs
-- Check test quality standards
-- Identify missing test scenarios
-- Suggest improvements before merge
-
-## Version Support
-
-- **Node.js**: 16+ (Jest 29+, Vitest 0.34+)
-- **Python**: 3.8+ (Pytest 7+)
-- **Java**: 11+ (JUnit 5.9+)
-- **TypeScript**: 4.5+
-
-## Related Skills
-
-This skill works well with:
-- **code-review**: Validate test quality during reviews
-- **refactoring-assistant**: Maintain tests during refactoring
-- **ci-cd-helper**: Integrate coverage in pipelines
-- **documentation-generator**: Generate test documentation
+| Scope | Details |
+|-------|---------|
+| Unit test focus | Integration and E2E tests require different patterns |
+| Static analysis | Cannot execute tests or measure runtime behavior |
+| Language support | Best for TypeScript, JavaScript, Python, Java |
+| Report formats | LCOV, JSON, XML only; other formats need conversion |
+| Generated tests | Provide scaffolding; require human review for complex logic |
+
+**When to use other tools:**
+- E2E testing: Playwright, Cypress, Selenium
+- Performance testing: k6, JMeter, Locust
+- Security testing: OWASP ZAP, Burp Suite
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@`
`117`	`117`	`"name": "tdd-guide",`
`118`	`118`	`"source": "../../engineering-team/tdd-guide",`
`119`	`119`	`"category": "engineering",`
`120`		`- "description": "Comprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation"`
	`120`	`+ "description": "Test-driven development workflow with test generation, coverage analysis, and multi-framework support"`
`121`	`121`	`},`
`122`	`122`	`{`
`123`	`123`	`"name": "tech-stack-evaluator",`