gkt-node 3.3.0

package/assets/.agent/skills/test-generator/data/test_patterns.json

@@ -0,0 +1,39 @@
+{
+    "test_patterns": {
+        "unit_test": {
+            "description": "Test individual functions/methods in isolation",
+            "jest_template": "describe('{FunctionName}', () => {\n  it('should return expected result for valid input', () => {\n    const result = {functionName}({validInput});\n    expect(result).toEqual({expectedOutput});\n  });\n\n  it('should throw error for invalid input', () => {\n    expect(() => {functionName}({invalidInput})).toThrow();\n  });\n\n  it('should handle edge case', () => {\n    const result = {functionName}({edgeCaseInput});\n    expect(result).toEqual({edgeCaseOutput});\n  });\n});",
+            "pytest_template": "class Test{ClassName}:\n    def test_valid_input(self):\n        result = {function_name}({valid_input})\n        assert result == {expected_output}\n\n    def test_invalid_input(self):\n        with pytest.raises(ValueError):\n            {function_name}({invalid_input})\n\n    def test_edge_case(self):\n        result = {function_name}({edge_case})\n        assert result == {edge_output}"
+        },
+        "integration_test": {
+            "description": "Test interaction between multiple components",
+            "api_test_template": "describe('POST /api/users', () => {\n  it('should create a new user', async () => {\n    const res = await request(app)\n      .post('/api/users')\n      .send({ email: 'test@test.com', password: 'Pass123!' })\n      .expect(201);\n    expect(res.body.data).toHaveProperty('id');\n  });\n\n  it('should return 400 for invalid email', async () => {\n    const res = await request(app)\n      .post('/api/users')\n      .send({ email: 'invalid', password: 'Pass123!' })\n      .expect(400);\n  });\n});"
+        },
+        "component_test": {
+            "description": "Test React/Vue components",
+            "react_template": "describe('{ComponentName}', () => {\n  it('renders correctly', () => {\n    render(<{ComponentName} />);\n    expect(screen.getByText('{expectedText}')).toBeInTheDocument();\n  });\n\n  it('handles click event', () => {\n    const onClick = jest.fn();\n    render(<{ComponentName} onClick={onClick} />);\n    fireEvent.click(screen.getByRole('button'));\n    expect(onClick).toHaveBeenCalledTimes(1);\n  });\n});"
+        }
+    },
+    "coverage_targets": {
+        "minimum": "60% — acceptable for startups",
+        "good": "80% — recommended for production apps",
+        "excellent": "90%+ — critical systems (fintech, healthcare)"
+    },
+    "testing_pyramid": {
+        "unit": {
+            "percentage": "70%",
+            "speed": "fast",
+            "cost": "low"
+        },
+        "integration": {
+            "percentage": "20%",
+            "speed": "medium",
+            "cost": "medium"
+        },
+        "e2e": {
+            "percentage": "10%",
+            "speed": "slow",
+            "cost": "high"
+        }
+    }
+}

package/assets/.agent/skills/test-generator/scripts/gen_skeleton.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Test Generator — Generate Test Skeletons (Zero Token).
+
+Usage:
+    python gen_skeleton.py <src_file>
+"""
+
+import argparse
+import re
+from pathlib import Path
+
+def generate_python_tests(content):
+    # Find functions: def my_func(...):
+    funcs = re.findall(r'def\s+([a-zA-Z_0-9]+)\s*\(', content)
+    
+    print("import pytest")
+    print("from src import module  # Update import\n")
+    
+    for f in funcs:
+        if f.startswith('_'): continue
+        print(f"def test_{f}():")
+        print(f"    # TODO: Implement test for {f}")
+        print(f"    assert True\n")
+
+def generate_js_tests(content):
+    # Find functions: function myFunc() or const myFunc = ...
+    funcs = re.findall(r'function\s+([a-zA-Z_0-9]+)', content)
+    arrow_funcs = re.findall(r'(?:const|let|var)\s+([a-zA-Z_0-9]+)\s*=\s*\(', content)
+    
+    all_funcs = funcs + arrow_funcs
+    
+    print("import { expect, test } from 'vitest';\n")
+    
+    for f in all_funcs:
+        print(f"test('{f} should work', () => {{")
+        print(f"  // TODO: Implement test for {f}")
+        print(f"  expect(true).toBe(true);")
+        print(f"}});\n")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("file")
+    args = parser.parse_args()
+    
+    p = Path(args.file)
+    if not p.exists():
+        return
+        
+    with open(p, 'r', encoding='utf-8') as f:
+        content = f.read()
+        
+    if p.suffix == '.py':
+        generate_python_tests(content)
+    elif p.suffix in ['.js', '.ts', '.jsx', '.tsx']:
+        generate_js_tests(content)
+    else:
+        print(f"// No test generator for {p.suffix}")
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/testing-patterns/SKILL.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/assets/.agent/skills/threat-mitigation-mapping/SKILL.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.