codingwithagent 1.0.0

package/templates/antigravity/strict/.agent/rules/testing.md

@@ -0,0 +1,280 @@
+---
+trigger: always_on
+---
+
+---
+
+# Testing Standards - STRICT (90% Coverage Minimum)
+
+## Testing Philosophy - ZERO TOLERANCE
+
+- 90% coverage MINIMUM (not 80%)
+- ALL new code MUST have tests before PR
+- Tests are NOT optional
+- Coverage decrease = automatic PR rejection
+- Flaky tests = automatic PR rejection
+- Tests MUST catch real bugs
+
+## Coverage Requirements - MANDATORY
+
+### Minimum Coverage - HARD LIMITS
+
+- Overall coverage: 90% (no exceptions)
+- Statement coverage: 90%
+- Branch coverage: 85%
+- Function coverage: 90%
+- Line coverage: 90%
+- Components: 100% coverage REQUIRED
+
+### Coverage Enforcement
+
+- CI/CD blocks merge if coverage < 90%
+- Coverage reports REQUIRED in every PR
+- Coverage badge MUST be green
+- Coverage decrease by >1% = automatic rejection
+
+## Unit Testing - STRICT STANDARDS
+
+### What MUST Be Tested - ALL REQUIRED
+
+- ALL exported functions
+- ALL components (100% coverage)
+- ALL conditional logic paths
+- ALL event handlers
+- ALL hooks (custom and standard)
+- ALL error states
+- ALL loading states
+- ALL edge cases
+
+### What NOT to Test
+
+- Third-party library internals ONLY
+- Trivial getters/setters ONLY if truly trivial
+- Constants (unless computed)
+
+### Test Structure - MANDATORY FORMAT
+
+```typescript
+describe("ComponentName", () => {
+  // Setup
+  let wrapper: ShallowWrapper;
+  let props: Props;
+
+  beforeEach(() => {
+    props = {
+      // complete props with realistic values
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  // Tests grouped by functionality
+  describe("rendering", () => {
+    it("should render with required props only", () => {
+      wrapper = shallow(<ComponentName {...props} />);
+      expect(wrapper.exists()).toBe(true);
+    });
+
+    it("should display title when provided", () => {
+      wrapper = shallow(<ComponentName {...props} title="Test" />);
+      expect(wrapper.find(".title").text()).toBe("Test");
+    });
+  });
+
+  describe("user interactions", () => {
+    it("should call onClick handler when button clicked", () => {
+      const mockOnClick = jest.fn();
+      wrapper = shallow(<ComponentName {...props} onClick={mockOnClick} />);
+
+      wrapper.find("button").simulate("click");
+
+      expect(mockOnClick).toHaveBeenCalledTimes(1);
+      expect(mockOnClick).toHaveBeenCalledWith(/* expected args */);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should display error message when error prop provided", () => {
+      wrapper = shallow(<ComponentName {...props} error="Error occurred" />);
+      expect(wrapper.find(".error").text()).toBe("Error occurred");
+    });
+  });
+});
+```
+
+### Test Naming - STRICT REQUIREMENTS
+
+- Format: "should [expected behavior] when [condition]"
+- Be SPECIFIC (no "works correctly", "renders", "is defined")
+- Test names MUST describe user behavior
+
+```typescript
+// CORRECT
+it("should disable submit button when form is invalid", () => {});
+it("should display error message when API call fails", () => {});
+it("should focus input when modal opens", () => {});
+
+// INCORRECT - TOO VAGUE
+it("works", () => {}); // REJECTED
+it("renders correctly", () => {}); // REJECTED
+it("handles errors", () => {}); // REJECTED
+```
+
+## Component Testing - 100% COVERAGE REQUIRED
+
+### ALL These MUST Be Tested
+
+- Rendering with all prop combinations
+- All conditional rendering paths
+- All event handlers
+- All state changes
+- All hooks and their effects
+- All error boundaries
+- All loading states
+- Accessibility (keyboard, ARIA)
+
+### Rendering Tests - MANDATORY
+
+```typescript
+// Test all prop combinations
+it("should render with minimal props", () => {});
+it("should render with all optional props", () => {});
+it("should render in loading state", () => {});
+it("should render in error state", () => {});
+it("should render when data is empty", () => {});
+it("should render when data is populated", () => {});
+```
+
+### Interaction Tests - ALL REQUIRED
+
+```typescript
+// Test ALL user interactions
+it("should call onClick when button clicked", () => {});
+it("should prevent default on form submit", () => {});
+it("should update state when input changes", () => {});
+it("should call onSubmit with form data", () => {});
+it("should focus input on mount", () => {});
+it("should trap focus in modal", () => {});
+```
+
+### Accessibility Tests - MANDATORY
+
+```typescript
+// Test keyboard navigation
+it("should be focusable with Tab key", () => {});
+it("should activate with Enter key", () => {});
+it("should close with Escape key", () => {});
+
+// Test ARIA attributes
+it("should have correct aria-label", () => {});
+it("should announce errors to screen readers", () => {});
+it("should have proper role attribute", () => {});
+```
+
+## Hooks Testing - STRICT REQUIREMENTS
+
+### Custom Hooks - 100% Coverage
+
+```typescript
+import { renderHook, act } from "@testing-library/react-hooks";
+
+describe("useCustomHook", () => {
+  it("should initialize with default value", () => {
+    const { result } = renderHook(() => useCustomHook());
+    expect(result.current.value).toBe(defaultValue);
+  });
+
+  it("should update value when action called", () => {
+    const { result } = renderHook(() => useCustomHook());
+
+    act(() => {
+      result.current.updateValue(newValue);
+    });
+
+    expect(result.current.value).toBe(newValue);
+  });
+
+  it("should cleanup on unmount", () => {
+    const cleanup = jest.fn();
+    const { unmount } = renderHook(() => useCustomHook(cleanup));
+
+    unmount();
+
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+});
+```
+
+## Mocking - STRICT STANDARDS
+
+### MUST Mock These
+
+- All external API calls
+- ALL Redux store and actions
+- ALL browser APIs (localStorage, window, document)
+- ALL third-party libraries
+- ALL time-dependent functions (Date, moment)
+- ALL file system operations
+- ALL network requests
+
+### Mock Pattern - MANDATORY
+
+```typescript
+// Mock at top of file
+jest.mock("../utils/api", () => ({
+  fetchData: jest.fn(),
+  postData: jest.fn(),
+}));
+
+// Use in tests
+import { fetchData } from "../utils/api";
+
+describe("Component", () => {
+  beforeEach(() => {
+    (fetchData as jest.Mock).mockResolvedValue({ data: "test" });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+});
+```
+
+### What NOT to Mock
+
+- Component's own functions (test real behavior)
+- Simple utility functions (test actual implementation)
+- React internals (useState, useEffect, etc.)
+- PropTypes validation
+
+## Test Quality - STRICT ENFORCEMENT
+
+### Prohibited - AUTOMATIC REJECTION
+
+- NO snapshot tests (explicit assertions ONLY)
+- NO test.skip in committed code
+- NO test.only in committed code
+- NO fit or fdescribe
+- NO flaky tests (must pass 100% of time)
+- NO setTimeout > 100ms
+- NO tests depending on execution order
+- NO tests with side effects
+
+### Required - ALL MANDATORY
+
+- Descriptive test names
+- Arrange-Act-Assert pattern
+- Independent tests (no shared state)
+- Fast tests (<100ms per test)
+- Deterministic tests (same input = same output)
+- Isolated tests (mock external dependencies)

package/templates/minimal/.cursorrules

@@ -0,0 +1,48 @@
+# Agentic Code Standards - Minimal Profile
+
+# Version: 1.0.0
+
+# Profile: Essential rules only - great for getting started
+
+## Core Principles
+
+- Write clean, readable code
+- Follow basic accessibility guidelines
+- Use modern JavaScript/TypeScript patterns
+
+## Accessibility Basics
+
+- All interactive elements must be keyboard accessible (Tab, Enter, Space)
+- Provide alt text for images that convey information
+- Use semantic HTML elements (button, nav, main, header, footer)
+- Minimum color contrast: 4.5:1 for normal text
+
+## Code Quality
+
+- Use descriptive variable and function names
+- Prefer `const` over `let`, never use `var`
+- Keep functions small and focused (under 50 lines)
+- Remove `console.log` statements before committing
+
+## React Essentials
+
+- Use functional components with hooks
+- Destructure props: `const Component = ({prop1, prop2}) => {}`
+- Extract reusable logic into custom hooks
+- Keep components under 200 lines
+
+## Testing
+
+- Write tests for critical functionality
+- Test user behavior, not implementation details
+- Mock external dependencies
+
+## Security
+
+- Never commit API keys or secrets
+- Validate user inputs
+- Use environment variables for configuration
+
+---
+
+Learn more: https://github.com/netshdev/codingwithagent

package/templates/minimal/README.md

@@ -0,0 +1,40 @@
+# Minimal Profile
+
+Essential coding standards for getting started with AI agents.
+
+## What's Included
+
+- Basic accessibility requirements
+- Naming conventions
+- React component basics
+- Code quality essentials
+
+## Best For
+
+- Small projects
+- Getting started
+- Rapid prototyping
+- Personal projects
+
+## Coverage
+
+- Keyboard navigation
+- Alt text for images
+- Semantic HTML
+- Basic React patterns
+
+## Quick Start
+
+```bash
+npx codingwithagent init
+# Select: 1. Minimal
+```
+
+### What you get
+
+A `.cursorrules` file with the rules focusing on:
+
+- Clean, readable code
+- Basic accessibility compliance
+- Modern JavaScript patterns
+- Simple React best practices

package/templates/standard/.cursorrules

@@ -0,0 +1,184 @@
+# Agentic Code Standards - Standard Profile
+
+# Version: 1.0.0
+
+# Profile: Recommended baseline for production code ⭐
+
+## Core Principles
+
+- Write accessible, maintainable, and secure code
+- Follow WCAG 2.1 Level AA standards
+- Use modern JavaScript/TypeScript patterns
+- Test thoroughly, document clearly
+
+## Accessibility Standards
+
+### Keyboard Navigation
+
+- All interactive elements must be keyboard accessible
+- Support Tab, Enter, Space, Escape keys
+- Visible focus indicators required
+- Never use `tabIndex > 0`
+
+### Screen Readers
+
+- Use semantic HTML (header, nav, main, footer, button)
+- Provide meaningful alt text for images
+- Use ARIA labels only when semantic HTML isn't enough
+- Test with screen readers (NVDA, JAWS, VoiceOver)
+
+### Visual Accessibility
+
+- Minimum contrast ratio: 4.5:1 for normal text, 3:1 for large text
+- Never use color alone to convey information
+- Support text resize up to 200%
+- Interactive elements minimum size: 24x24 pixels
+
+### Forms
+
+- All form fields must have associated labels
+- Provide clear error messages
+- Indicate required fields
+- Support keyboard navigation throughout
+
+## React & Components
+
+### Component Structure
+
+- Use functional components with hooks (not class components)
+- Destructure props at function signature: `const Component = ({prop1, prop2}) => {}`
+- Keep components under 200 lines - refactor if longer
+- One component per file (except small helper components)
+
+### Props & State
+
+- Define PropTypes for all components
+- Mark required props with `.isRequired`
+- Use TypeScript for type safety
+- Local state for UI only, Redux/context for shared data
+- Avoid prop drilling beyond 3 levels
+
+### Hooks Best Practices
+
+- `useState`: UI-only state (modals, toggles)
+- `useEffect`: Side effects, subscriptions, API calls
+  - Always specify dependencies array
+  - Return cleanup functions for subscriptions
+- `useMemo`: Expensive calculations only
+- `useCallback`: Prevent unnecessary re-renders
+- `useRef`: DOM access, mutable values that don't trigger re-renders
+
+### JSX Standards
+
+- No anonymous functions in render: `onClick={handleClick}` not `onClick={() => handleClick()}`
+- Use fragments `<></>` instead of unnecessary divs
+- Keys from data, not array index: `key={item.id}` not `key={index}`
+- Conditional rendering with boolean values only
+- Extract complex JSX to separate components
+
+## Code Quality
+
+### JavaScript/TypeScript
+
+- Use TypeScript for type safety
+- Prefer `const` over `let`, never use `var`
+- Use arrow functions for callbacks
+- Destructure objects and arrays
+- Use template literals for string interpolation
+- Async/await instead of promise chains
+
+### Naming Conventions
+
+- Variables & functions: `camelCase` (getUserData)
+- Components: `PascalCase` (UserProfile)
+- Constants: `UPPER_SNAKE_CASE` (MAX_RETRIES)
+- Files: `kebab-case` (user-profile.jsx)
+- Be descriptive: `isUserAuthenticated` not `isAuth`
+
+### Functions
+
+- Pure functions when possible (no side effects)
+- Maximum function length: 50 lines
+- Single responsibility principle
+- Return early to reduce nesting
+- Use meaningful parameter names
+
+### Prohibited Patterns
+
+- No `console.log` in production code
+- No `window` object access (use approved utilities)
+- No `eslint-disable` without team approval
+- No direct DOM manipulation (use React refs if needed)
+- No inline styles (use CSS/styled-components)
+
+## Testing Standards
+
+### Coverage Requirements
+
+- Aim for 80%+ coverage on new code
+- All new features must have tests
+- Test user behavior, not implementation
+- Use descriptive test names
+
+### Testing Best Practices
+
+- Shallow render preferred (use mount only for hooks)
+- Mock external dependencies (APIs, Redux, third-party libs)
+- Clean up mocks with `afterEach(() => jest.clearAllMocks())`
+- Avoid snapshots (explicit assertions preferred)
+- Test accessibility (keyboard nav, ARIA labels)
+
+## Security
+
+### Data Protection
+
+- Never commit secrets, API keys, or credentials
+- Use environment variables for configuration
+- Validate all user inputs
+- Sanitize data before rendering
+- Follow PII/PCI data handling guidelines
+
+### Dependencies
+
+- Keep dependencies up to date
+- Review security advisories regularly
+- Audit third-party packages before use
+- Minimize dependency count
+
+## Performance
+
+### Optimization
+
+- Code splitting for large bundles
+- Lazy load routes and components
+- Memoize expensive calculations with `useMemo`
+- Prevent unnecessary re-renders with `React.memo` and `useCallback`
+- Optimize images (WebP, proper sizing)
+
+### Best Practices
+
+- Avoid large component trees
+- Debounce expensive operations
+- Virtualize long lists
+- Monitor bundle size
+
+## Pull Request Standards
+
+### Before Submitting
+
+- All tests pass locally
+- No linting errors
+- Code coverage maintained or increased
+- CHANGELOG.md updated
+- Self-review completed
+
+### PR Description
+
+- Clear title describing the change
+- Reference related issues
+- Include screenshots for UI changes
+- List testing steps
+
+---
+
+Full documentation: https://github.com/netshdev/codingwithagent

package/templates/standard/README.md

@@ -0,0 +1,43 @@
+# Standard Profile ⭐
+
+Recommended baseline for production applications. Most popular choice.
+
+## What's Included
+
+- WCAG 2.1 Level AA accessibility
+- Comprehensive React patterns
+- Testing standards (80%+ coverage)
+- Security best practices
+- Performance guidelines
+
+## Best For
+
+- Production applications
+- Team projects
+- Client work
+- Long-term maintenance
+
+## Coverage
+
+- Full keyboard accessibility
+- Screen reader compatibility
+- Component best practices
+- Testing requirements
+- Pull request standards
+
+## Quick Start
+
+```bash
+npx codingwithagent init
+# Select: 2. Standard
+```
+
+### What you get
+
+A `.cursorrules` file with the rules focusing on:
+
+- Accessibility (WCAG 2.1 AA)
+- React & TypeScript
+- Testing & coverage
+- Security & PII
+- Code quality & performance