@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/test-fixing.md

@@ -0,0 +1,119 @@
+---
+name: test-fixing
+description: Run tests and systematically fix all failing tests using smart error grouping. Use when user asks to fix failing tests, mentions test failures, runs test suite and failures occur, or requests to make tests pass.
+---
+
+# Test Fixing
+
+Systematically identify and fix all failing tests using smart grouping strategies.
+
+## When to Use
+
+- Explicitly asks to fix tests ("fix these tests", "make tests pass")
+- Reports test failures ("tests are failing", "test suite is broken")
+- Completes implementation and wants tests passing
+- Mentions CI/CD failures due to tests
+
+## Systematic Approach
+
+### 1. Initial Test Run
+
+Run `make test` to identify all failing tests.
+
+Analyze output for:
+
+- Total number of failures
+- Error types and patterns
+- Affected modules/files
+
+### 2. Smart Error Grouping
+
+Group similar failures by:
+
+- **Error type**: ImportError, AttributeError, AssertionError, etc.
+- **Module/file**: Same file causing multiple test failure
+- **Root cause**: Missing dependencies, API changes, refactoring impacts
+
+Prioritize groups by:
+
+- Number of affected tests (highest impact first)
+- Dependency order (fix infrastructure before functionality)
+
+### 3. Systematic Fixing Process
+
+For each group (starting with highest impact):
+
+1. **Identify root cause**
+
+   - Read relevant code
+   - Check recent changes with `git diff`
+   - Understand the error pattern
+
+2. **Implement fix**
+
+   - Use Edit tool for code changes
+   - Follow project conventions (see CLAUDE.md)
+   - Make minimal, focused changes
+
+3. **Verify fix**
+
+   - Run subset of tests for this group
+   - Use pytest markers or file patterns:
+     ```bash
+     uv run pytest tests/path/to/test_file.py -v
+     uv run pytest -k "pattern" -v
+     ```
+   - Ensure group passes before moving on
+
+4. **Move to next group**
+
+### 4. Fix Order Strategy
+
+**Infrastructure first:**
+
+- Import errors
+- Missing dependencies
+- Configuration issues
+
+**Then API changes:**
+
+- Function signature changes
+- Module reorganization
+- Renamed variables/functions
+
+**Finally, logic issues:**
+
+- Assertion failures
+- Business logic bugs
+- Edge case handling
+
+### 5. Final Verification
+
+After all groups fixed:
+
+- Run complete test suite: `make test`
+- Verify no regressions
+- Check test coverage remains intact
+
+## Best Practices
+
+- Fix one group at a time
+- Run focused tests after each fix
+- Use `git diff` to understand recent changes
+- Look for patterns in failures
+- Don't move to next group until current passes
+- Keep changes minimal and focused
+
+## Example Workflow
+
+User: "The tests are failing after my refactor"
+
+1. Run `make test` → 15 failures identified
+2. Group errors:
+   - 8 ImportErrors (module renamed)
+   - 5 AttributeErrors (function signature changed)
+   - 2 AssertionErrors (logic bugs)
+3. Fix ImportErrors first → Run subset → Verify
+4. Fix AttributeErrors → Run subset → Verify
+5. Fix AssertionErrors → Run subset → Verify
+6. Run full suite → All pass ✓

package/merged-commands/test-master.md

@@ -0,0 +1,104 @@
+---
+name: test-master
+description: Use when writing tests, creating test strategies, or building automation frameworks. Invoke for unit tests, integration tests, E2E, coverage analysis, performance testing, security testing.
+triggers:
+  - test
+  - testing
+  - QA
+  - unit test
+  - integration test
+  - E2E
+  - coverage
+  - performance test
+  - security test
+  - regression
+  - test strategy
+  - test automation
+  - test framework
+  - quality metrics
+  - defect
+  - exploratory
+  - usability
+  - accessibility
+  - localization
+  - manual testing
+  - shift-left
+  - quality gate
+  - flaky test
+  - test maintenance
+role: specialist
+scope: testing
+output-format: report
+---
+
+# Test Master
+
+Comprehensive testing specialist ensuring software quality through functional, performance, and security testing.
+
+## Role Definition
+
+You are a senior QA engineer with 12+ years of testing experience. You think in three testing modes: **[Test]** for functional correctness, **[Perf]** for performance, **[Security]** for vulnerability testing. You ensure features work correctly, perform well, and are secure.
+
+## When to Use This Skill
+
+- Writing unit, integration, or E2E tests
+- Creating test strategies and plans
+- Analyzing test coverage and quality metrics
+- Building test automation frameworks
+- Performance testing and benchmarking
+- Security testing for vulnerabilities
+- Managing defects and test reporting
+- Debugging test failures
+- Manual testing (exploratory, usability, accessibility)
+- Scaling test automation and CI/CD integration
+
+## Core Workflow
+
+1. **Define scope** - Identify what to test and testing types needed
+2. **Create strategy** - Plan test approach using all three perspectives
+3. **Write tests** - Implement tests with proper assertions
+4. **Execute** - Run tests and collect results
+5. **Report** - Document findings with actionable recommendations
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Unit Testing | `references/unit-testing.md` | Jest, Vitest, pytest patterns |
+| Integration | `references/integration-testing.md` | API testing, Supertest |
+| E2E | `references/e2e-testing.md` | E2E strategy, user flows |
+| Performance | `references/performance-testing.md` | k6, load testing |
+| Security | `references/security-testing.md` | Security test checklist |
+| Reports | `references/test-reports.md` | Report templates, findings |
+| QA Methodology | `references/qa-methodology.md` | Manual testing, quality advocacy, shift-left, continuous testing |
+| Automation | `references/automation-frameworks.md` | Framework patterns, scaling, maintenance, team enablement |
+<!-- Rows below adapted from obra/superpowers by Jesse Vincent (@obra), MIT License -->
+| TDD Iron Laws | `references/tdd-iron-laws.md` | TDD methodology, test-first development, red-green-refactor |
+| Testing Anti-Patterns | `references/testing-anti-patterns.md` | Test review, mock issues, test quality problems |
+
+## Constraints
+
+**MUST DO**: Test happy paths AND error cases, mock external dependencies, use meaningful descriptions, assert specific outcomes, test edge cases, run in CI/CD, document coverage gaps
+
+**MUST NOT**: Skip error testing, use production data, create order-dependent tests, ignore flaky tests, test implementation details, leave debug code
+
+## Output Templates
+
+When creating test plans, provide:
+1. Test scope and approach
+2. Test cases with expected outcomes
+3. Coverage analysis
+4. Findings with severity (Critical/High/Medium/Low)
+5. Specific fix recommendations
+
+## Knowledge Reference
+
+Jest, Vitest, pytest, React Testing Library, Supertest, Playwright, Cypress, k6, Artillery, OWASP testing, code coverage, mocking, fixtures, test automation frameworks, CI/CD integration, quality metrics, defect management, BDD, page object model, screenplay pattern, exploratory testing, accessibility (WCAG), usability testing, shift-left testing, quality gates
+
+## Related Skills
+
+- **Fullstack Guardian** - Receives features for testing
+- **Playwright Expert** - E2E testing specifics
+- **DevOps Engineer** - CI/CD test integration

package/merged-commands/testing-patterns.md

@@ -0,0 +1,259 @@
+---
+name: testing-patterns
+description: Jest testing patterns, factory functions, mocking strategies, and TDD workflow. Use when writing unit tests, creating test factories, or following TDD red-green-refactor cycle.
+---
+
+# Testing Patterns and Utilities
+
+## Testing Philosophy
+
+**Test-Driven Development (TDD):**
+- Write failing test FIRST
+- Implement minimal code to pass
+- Refactor after green
+- Never write production code without a failing test
+
+**Behavior-Driven Testing:**
+- Test behavior, not implementation
+- Focus on public APIs and business requirements
+- Avoid testing implementation details
+- Use descriptive test names that describe behavior
+
+**Factory Pattern:**
+- Create `getMockX(overrides?: Partial<X>)` functions
+- Provide sensible defaults
+- Allow overriding specific properties
+- Keep tests DRY and maintainable
+
+## Test Utilities
+
+### Custom Render Function
+
+Create a custom render that wraps components with required providers:
+
+```typescript
+// src/utils/testUtils.tsx
+import { render } from '@testing-library/react-native';
+import { ThemeProvider } from './theme';
+
+export const renderWithTheme = (ui: React.ReactElement) => {
+  return render(
+    <ThemeProvider>{ui}</ThemeProvider>
+  );
+};
+```
+
+**Usage:**
+```typescript
+import { renderWithTheme } from 'utils/testUtils';
+import { screen } from '@testing-library/react-native';
+
+it('should render component', () => {
+  renderWithTheme(<MyComponent />);
+  expect(screen.getByText('Hello')).toBeTruthy();
+});
+```
+
+## Factory Pattern
+
+### Component Props Factory
+
+```typescript
+import { ComponentProps } from 'react';
+
+const getMockMyComponentProps = (
+  overrides?: Partial<ComponentProps<typeof MyComponent>>
+) => {
+  return {
+    title: 'Default Title',
+    count: 0,
+    onPress: jest.fn(),
+    isLoading: false,
+    ...overrides,
+  };
+};
+
+// Usage in tests
+it('should render with custom title', () => {
+  const props = getMockMyComponentProps({ title: 'Custom Title' });
+  renderWithTheme(<MyComponent {...props} />);
+  expect(screen.getByText('Custom Title')).toBeTruthy();
+});
+```
+
+### Data Factory
+
+```typescript
+interface User {
+  id: string;
+  name: string;
+  email: string;
+  role: 'admin' | 'user';
+}
+
+const getMockUser = (overrides?: Partial<User>): User => {
+  return {
+    id: '123',
+    name: 'John Doe',
+    email: 'john@example.com',
+    role: 'user',
+    ...overrides,
+  };
+};
+
+// Usage
+it('should display admin badge for admin users', () => {
+  const user = getMockUser({ role: 'admin' });
+  renderWithTheme(<UserCard user={user} />);
+  expect(screen.getByText('Admin')).toBeTruthy();
+});
+```
+
+## Mocking Patterns
+
+### Mocking Modules
+
+```typescript
+// Mock entire module
+jest.mock('utils/analytics');
+
+// Mock with factory function
+jest.mock('utils/analytics', () => ({
+  Analytics: {
+    logEvent: jest.fn(),
+  },
+}));
+
+// Access mock in test
+const mockLogEvent = jest.requireMock('utils/analytics').Analytics.logEvent;
+```
+
+### Mocking GraphQL Hooks
+
+```typescript
+jest.mock('./GetItems.generated', () => ({
+  useGetItemsQuery: jest.fn(),
+}));
+
+const mockUseGetItemsQuery = jest.requireMock(
+  './GetItems.generated'
+).useGetItemsQuery as jest.Mock;
+
+// In test
+mockUseGetItemsQuery.mockReturnValue({
+  data: { items: [] },
+  loading: false,
+  error: undefined,
+});
+```
+
+## Test Structure
+
+```typescript
+describe('ComponentName', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Rendering', () => {
+    it('should render component with default props', () => {});
+    it('should render loading state when loading', () => {});
+  });
+
+  describe('User interactions', () => {
+    it('should call onPress when button is clicked', async () => {});
+  });
+
+  describe('Edge cases', () => {
+    it('should handle empty data gracefully', () => {});
+  });
+});
+```
+
+## Query Patterns
+
+```typescript
+// Element must exist
+expect(screen.getByText('Hello')).toBeTruthy();
+
+// Element should not exist
+expect(screen.queryByText('Goodbye')).toBeNull();
+
+// Element appears asynchronously
+await waitFor(() => {
+  expect(screen.findByText('Loaded')).toBeTruthy();
+});
+```
+
+## User Interaction Patterns
+
+```typescript
+import { fireEvent, screen } from '@testing-library/react-native';
+
+it('should submit form on button click', async () => {
+  const onSubmit = jest.fn();
+  renderWithTheme(<LoginForm onSubmit={onSubmit} />);
+
+  fireEvent.changeText(screen.getByLabelText('Email'), 'user@example.com');
+  fireEvent.changeText(screen.getByLabelText('Password'), 'password123');
+  fireEvent.press(screen.getByTestId('login-button'));
+
+  await waitFor(() => {
+    expect(onSubmit).toHaveBeenCalled();
+  });
+});
+```
+
+## Anti-Patterns to Avoid
+
+### Testing Mock Behavior Instead of Real Behavior
+
+```typescript
+// Bad - testing the mock
+expect(mockFetchData).toHaveBeenCalled();
+
+// Good - testing actual behavior
+expect(screen.getByText('John Doe')).toBeTruthy();
+```
+
+### Not Using Factories
+
+```typescript
+// Bad - duplicated, inconsistent test data
+it('test 1', () => {
+  const user = { id: '1', name: 'John', email: 'john@test.com', role: 'user' };
+});
+it('test 2', () => {
+  const user = { id: '2', name: 'Jane', email: 'jane@test.com' }; // Missing role!
+});
+
+// Good - reusable factory
+const user = getMockUser({ name: 'Custom Name' });
+```
+
+## Best Practices
+
+1. **Always use factory functions** for props and data
+2. **Test behavior, not implementation**
+3. **Use descriptive test names**
+4. **Organize with describe blocks**
+5. **Clear mocks between tests**
+6. **Keep tests focused** - one behavior per test
+
+## Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run with coverage
+npm run test:coverage
+
+# Run specific file
+npm test ComponentName.test.tsx
+```
+
+## Integration with Other Skills
+
+- **react-ui-patterns**: Test all UI states (loading, error, empty, success)
+- **systematic-debugging**: Write test that reproduces bug before fixing

package/merged-commands/theme-factory.md

@@ -0,0 +1,59 @@
+---
+name: theme-factory
+description: Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.
+license: Complete terms in LICENSE.txt
+---
+
+
+# Theme Factory Skill
+
+This skill provides a curated collection of professional font and color themes themes, each with carefully selected color palettes and font pairings. Once a theme is chosen, it can be applied to any artifact.
+
+## Purpose
+
+To apply consistent, professional styling to presentation slide decks, use this skill. Each theme includes:
+- A cohesive color palette with hex codes
+- Complementary font pairings for headers and body text
+- A distinct visual identity suitable for different contexts and audiences
+
+## Usage Instructions
+
+To apply styling to a slide deck or other artifact:
+
+1. **Show the theme showcase**: Display the `theme-showcase.pdf` file to allow users to see all available themes visually. Do not make any modifications to it; simply show the file for viewing.
+2. **Ask for their choice**: Ask which theme to apply to the deck
+3. **Wait for selection**: Get explicit confirmation about the chosen theme
+4. **Apply the theme**: Once a theme has been chosen, apply the selected theme's colors and fonts to the deck/artifact
+
+## Themes Available
+
+The following 10 themes are available, each showcased in `theme-showcase.pdf`:
+
+1. **Ocean Depths** - Professional and calming maritime theme
+2. **Sunset Boulevard** - Warm and vibrant sunset colors
+3. **Forest Canopy** - Natural and grounded earth tones
+4. **Modern Minimalist** - Clean and contemporary grayscale
+5. **Golden Hour** - Rich and warm autumnal palette
+6. **Arctic Frost** - Cool and crisp winter-inspired theme
+7. **Desert Rose** - Soft and sophisticated dusty tones
+8. **Tech Innovation** - Bold and modern tech aesthetic
+9. **Botanical Garden** - Fresh and organic garden colors
+10. **Midnight Galaxy** - Dramatic and cosmic deep tones
+
+## Theme Details
+
+Each theme is defined in the `themes/` directory with complete specifications including:
+- Cohesive color palette with hex codes
+- Complementary font pairings for headers and body text
+- Distinct visual identity suitable for different contexts and audiences
+
+## Application Process
+
+After a preferred theme is selected:
+1. Read the corresponding theme file from the `themes/` directory
+2. Apply the specified colors and fonts consistently throughout the deck
+3. Ensure proper contrast and readability
+4. Maintain the theme's visual identity across all slides
+
+## Create your Own Theme
+To handle cases where none of the existing themes work for an artifact, create a custom theme. Based on provided inputs, generate a new theme similar to the ones above. Give the theme a similar name describing what the font/color combinations represent. Use any basic description provided to choose appropriate colors/fonts. After generating the theme, show it for review and verification. Following that, apply the theme as described above.

package/merged-commands/threat-mitigation-mapping.md

@@ -0,0 +1,33 @@
+---
+name: threat-mitigation-mapping
+description: Map identified threats to appropriate security controls and mitigations. Use when prioritizing security investments, creating remediation plans, or validating control effectiveness.
+---
+
+# Threat Mitigation Mapping
+
+Connect threats to controls for effective security planning.
+
+## Use this skill when
+
+- Prioritizing security investments
+- Creating remediation roadmaps
+- Validating control coverage
+- Designing defense-in-depth
+- Security architecture review
+- Risk treatment planning
+
+## Do not use this skill when
+
+- The task is unrelated to threat mitigation mapping
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.

package/merged-commands/threat-modeling-expert.md

@@ -0,0 +1,60 @@
+---
+name: threat-modeling-expert
+description: "Expert in threat modeling methodologies, security architecture review, and risk assessment. Masters STRIDE, PASTA, attack trees, and security requirement extraction. Use for security architecture reviews, threat identification, and secure-by-design planning."
+---
+
+# Threat Modeling Expert
+
+Expert in threat modeling methodologies, security architecture review, and risk assessment. Masters STRIDE, PASTA, attack trees, and security requirement extraction. Use PROACTIVELY for security architecture reviews, threat identification, or building secure-by-design systems.
+
+## Capabilities
+
+- STRIDE threat analysis
+- Attack tree construction
+- Data flow diagram analysis
+- Security requirement extraction
+- Risk prioritization and scoring
+- Mitigation strategy design
+- Security control mapping
+
+## Use this skill when
+
+- Designing new systems or features
+- Reviewing architecture for security gaps
+- Preparing for security audits
+- Identifying attack vectors
+- Prioritizing security investments
+- Creating security documentation
+- Training teams on security thinking
+
+## Do not use this skill when
+
+- You lack scope or authorization for security review
+- You need legal or compliance certification
+- You only need automated scanning without human review
+
+## Instructions
+
+1. Define system scope and trust boundaries
+2. Create data flow diagrams
+3. Identify assets and entry points
+4. Apply STRIDE to each component
+5. Build attack trees for critical paths
+6. Score and prioritize threats
+7. Design mitigations
+8. Document residual risks
+
+## Safety
+
+- Avoid storing sensitive details in threat models without access controls.
+- Keep threat models updated after architecture changes.
+
+## Best Practices
+
+- Involve developers in threat modeling sessions
+- Focus on data flows, not just components
+- Consider insider threats
+- Update threat models with architecture changes
+- Link threats to security requirements
+- Track mitigations to implementation
+- Review regularly, not just at design time

package/merged-commands/threejs-skills.md

@@ -0,0 +1,22 @@
+---
+name: threejs-skills
+description: "Three.js skills for creating 3D elements and interactive experiences"
+source: "https://github.com/CloudAI-X/threejs-skills"
+risk: safe
+---
+
+# Threejs Skills
+
+## Overview
+
+Three.js skills for creating 3D elements and interactive experiences
+
+## When to Use This Skill
+
+Use this skill when you need to work with three.js skills for creating 3d elements and interactive experiences.
+
+## Instructions
+
+This skill provides guidance and patterns for three.js skills for creating 3d elements and interactive experiences.
+
+For more information, see the [source repository](https://github.com/CloudAI-X/threejs-skills).