@ngxtm/devkit 3.7.0 → 3.9.0

package/merged-commands/javascript-testing-patterns.md

@@ -0,0 +1,35 @@
+---
+name: javascript-testing-patterns
+description: Implement comprehensive testing strategies using Jest, Vitest, and Testing Library for unit tests, integration tests, and end-to-end testing with mocking, fixtures, and test-driven development. Use when writing JavaScript/TypeScript tests, setting up test infrastructure, or implementing TDD/BDD workflows.
+---
+
+# JavaScript Testing Patterns
+
+Comprehensive guide for implementing robust testing strategies in JavaScript/TypeScript applications using modern testing frameworks and best practices.
+
+## Use this skill when
+
+- Setting up test infrastructure for new projects
+- Writing unit tests for functions and classes
+- Creating integration tests for APIs and services
+- Implementing end-to-end tests for user flows
+- Mocking external dependencies and APIs
+- Testing React, Vue, or other frontend components
+- Implementing test-driven development (TDD)
+- Setting up continuous testing in CI/CD pipelines
+
+## Do not use this skill when
+
+- The task is unrelated to javascript testing patterns
+- 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/javascript-typescript-typescript-scaffold.md

@@ -0,0 +1,361 @@
+---
+name: javascript-typescript-typescript-scaffold
+description: "You are a TypeScript project architecture expert specializing in scaffolding production-ready Node.js and frontend applications. Generate complete project structures with modern tooling (pnpm, Vite, N"
+---
+
+# TypeScript Project Scaffolding
+
+You are a TypeScript project architecture expert specializing in scaffolding production-ready Node.js and frontend applications. Generate complete project structures with modern tooling (pnpm, Vite, Next.js), type safety, testing setup, and configuration following current best practices.
+
+## Use this skill when
+
+- Working on typescript project scaffolding tasks or workflows
+- Needing guidance, best practices, or checklists for typescript project scaffolding
+
+## Do not use this skill when
+
+- The task is unrelated to typescript project scaffolding
+- You need a different domain or tool outside this scope
+
+## Context
+
+The user needs automated TypeScript project scaffolding that creates consistent, type-safe applications with proper structure, dependency management, testing, and build tooling. Focus on modern TypeScript patterns and scalable architecture.
+
+## Requirements
+
+$ARGUMENTS
+
+## Instructions
+
+### 1. Analyze Project Type
+
+Determine the project type from user requirements:
+- **Next.js**: Full-stack React applications, SSR/SSG, API routes
+- **React + Vite**: SPA applications, component libraries
+- **Node.js API**: Express/Fastify backends, microservices
+- **Library**: Reusable packages, utilities, tools
+- **CLI**: Command-line tools, automation scripts
+
+### 2. Initialize Project with pnpm
+
+```bash
+# Install pnpm if needed
+npm install -g pnpm
+
+# Initialize project
+mkdir project-name && cd project-name
+pnpm init
+
+# Initialize git
+git init
+echo "node_modules/" >> .gitignore
+echo "dist/" >> .gitignore
+echo ".env" >> .gitignore
+```
+
+### 3. Generate Next.js Project Structure
+
+```bash
+# Create Next.js project with TypeScript
+pnpm create next-app@latest . --typescript --tailwind --app --src-dir --import-alias "@/*"
+```
+
+```
+nextjs-project/
+├── package.json
+├── tsconfig.json
+├── next.config.js
+├── .env.example
+├── src/
+│   ├── app/
+│   │   ├── layout.tsx
+│   │   ├── page.tsx
+│   │   ├── api/
+│   │   │   └── health/
+│   │   │       └── route.ts
+│   │   └── (routes)/
+│   │       └── dashboard/
+│   │           └── page.tsx
+│   ├── components/
+│   │   ├── ui/
+│   │   │   ├── Button.tsx
+│   │   │   └── Card.tsx
+│   │   └── layout/
+│   │       ├── Header.tsx
+│   │       └── Footer.tsx
+│   ├── lib/
+│   │   ├── api.ts
+│   │   ├── utils.ts
+│   │   └── types.ts
+│   └── hooks/
+│       ├── useAuth.ts
+│       └── useFetch.ts
+└── tests/
+    ├── setup.ts
+    └── components/
+        └── Button.test.tsx
+```
+
+**package.json**:
+```json
+{
+  "name": "nextjs-project",
+  "version": "0.1.0",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "test": "vitest",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "next": "^14.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/react": "^18.2.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "eslint": "^8.56.0",
+    "eslint-config-next": "^14.1.0"
+  }
+}
+```
+
+**tsconfig.json**:
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "preserve",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "incremental": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "plugins": [{"name": "next"}]
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}
+```
+
+### 4. Generate React + Vite Project Structure
+
+```bash
+# Create Vite project
+pnpm create vite . --template react-ts
+```
+
+**vite.config.ts**:
+```typescript
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  server: {
+    port: 3000,
+  },
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: './tests/setup.ts',
+  },
+})
+```
+
+### 5. Generate Node.js API Project Structure
+
+```
+nodejs-api/
+├── package.json
+├── tsconfig.json
+├── src/
+│   ├── index.ts
+│   ├── app.ts
+│   ├── config/
+│   │   ├── database.ts
+│   │   └── env.ts
+│   ├── routes/
+│   │   ├── index.ts
+│   │   ├── users.ts
+│   │   └── health.ts
+│   ├── controllers/
+│   │   └── userController.ts
+│   ├── services/
+│   │   └── userService.ts
+│   ├── models/
+│   │   └── User.ts
+│   ├── middleware/
+│   │   ├── auth.ts
+│   │   └── errorHandler.ts
+│   └── types/
+│       └── express.d.ts
+└── tests/
+    └── routes/
+        └── users.test.ts
+```
+
+**package.json for Node.js API**:
+```json
+{
+  "name": "nodejs-api",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest",
+    "lint": "eslint src --ext .ts"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "dotenv": "^16.4.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0",
+    "tsx": "^4.7.0",
+    "vitest": "^1.2.0",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0"
+  }
+}
+```
+
+**src/app.ts**:
+```typescript
+import express, { Express } from 'express'
+import { healthRouter } from './routes/health.js'
+import { userRouter } from './routes/users.js'
+import { errorHandler } from './middleware/errorHandler.js'
+
+export function createApp(): Express {
+  const app = express()
+
+  app.use(express.json())
+  app.use('/health', healthRouter)
+  app.use('/api/users', userRouter)
+  app.use(errorHandler)
+
+  return app
+}
+```
+
+### 6. Generate TypeScript Library Structure
+
+```
+library-name/
+├── package.json
+├── tsconfig.json
+├── tsconfig.build.json
+├── src/
+│   ├── index.ts
+│   └── core.ts
+├── tests/
+│   └── core.test.ts
+└── dist/
+```
+
+**package.json for Library**:
+```json
+{
+  "name": "@scope/library-name",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest",
+    "prepublishOnly": "pnpm build"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  }
+}
+```
+
+### 7. Configure Development Tools
+
+**.env.example**:
+```env
+NODE_ENV=development
+PORT=3000
+DATABASE_URL=postgresql://user:pass@localhost:5432/db
+JWT_SECRET=your-secret-key
+```
+
+**vitest.config.ts**:
+```typescript
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+})
+```
+
+**.eslintrc.json**:
+```json
+{
+  "parser": "@typescript-eslint/parser",
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "rules": {
+    "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/no-unused-vars": "error"
+  }
+}
+```
+
+## Output Format
+
+1. **Project Structure**: Complete directory tree with all necessary files
+2. **Configuration**: package.json, tsconfig.json, build tooling
+3. **Entry Point**: Main application file with type-safe setup
+4. **Tests**: Test structure with Vitest configuration
+5. **Documentation**: README with setup and usage instructions
+6. **Development Tools**: .env.example, .gitignore, linting config
+
+Focus on creating production-ready TypeScript projects with modern tooling, strict type safety, and comprehensive testing setup.

package/merged-commands/javascript-typescript.md

@@ -0,0 +1,142 @@
+---
+name: javascript-typescript
+description: JavaScript and TypeScript development with ES6+, Node.js, React, and modern web frameworks. Use for frontend, backend, or full-stack JavaScript/TypeScript projects.
+source: wshobson/agents
+license: MIT
+---
+
+# JavaScript/TypeScript Development
+
+## TypeScript Configuration
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+```
+
+## Type Patterns
+
+### Utility Types
+```typescript
+// Pick specific properties
+type UserPreview = Pick<User, 'id' | 'name'>;
+
+// Omit properties
+type CreateUser = Omit<User, 'id' | 'createdAt'>;
+
+// Make all properties optional
+type PartialUser = Partial<User>;
+
+// Make all properties required
+type RequiredUser = Required<User>;
+
+// Extract union types
+type Status = 'pending' | 'active' | 'inactive';
+type ActiveStatus = Extract<Status, 'active' | 'pending'>;
+```
+
+### Discriminated Unions
+```typescript
+type Result<T> =
+  | { success: true; data: T }
+  | { success: false; error: Error };
+
+function handleResult<T>(result: Result<T>) {
+  if (result.success) {
+    console.log(result.data); // T
+  } else {
+    console.error(result.error); // Error
+  }
+}
+```
+
+### Generic Constraints
+```typescript
+interface HasId {
+  id: string | number;
+}
+
+function findById<T extends HasId>(items: T[], id: T['id']): T | undefined {
+  return items.find(item => item.id === id);
+}
+```
+
+## Modern JavaScript
+
+### Destructuring & Spread
+```javascript
+const { name, ...rest } = user;
+const merged = { ...defaults, ...options };
+const [first, ...others] = items;
+```
+
+### Optional Chaining & Nullish Coalescing
+```javascript
+const city = user?.address?.city ?? 'Unknown';
+const count = data?.items?.length ?? 0;
+```
+
+### Array Methods
+```javascript
+const adults = users.filter(u => u.age >= 18);
+const names = users.map(u => u.name);
+const total = items.reduce((sum, item) => sum + item.price, 0);
+const hasAdmin = users.some(u => u.role === 'admin');
+const allActive = users.every(u => u.active);
+```
+
+## React Patterns
+
+```typescript
+// Props with children
+interface CardProps {
+  title: string;
+  children: React.ReactNode;
+}
+
+// Event handlers
+interface ButtonProps {
+  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+
+// Custom hooks
+function useLocalStorage<T>(key: string, initial: T) {
+  const [value, setValue] = useState<T>(() => {
+    const stored = localStorage.getItem(key);
+    return stored ? JSON.parse(stored) : initial;
+  });
+
+  useEffect(() => {
+    localStorage.setItem(key, JSON.stringify(value));
+  }, [key, value]);
+
+  return [value, setValue] as const;
+}
+```
+
+## Node.js Patterns
+
+```typescript
+// ES Modules
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+// Error handling
+process.on('unhandledRejection', (reason) => {
+  console.error('Unhandled Rejection:', reason);
+  process.exit(1);
+});
+```

package/merged-commands/jira-issues.md

@@ -0,0 +1,181 @@
+---
+name: jira-issues
+description: Create, update, and manage Jira issues from natural language. Use when the user wants to log bugs, create tickets, update issue status, or manage their Jira backlog.
+license: MIT
+---
+
+# Jira Issue Management
+
+Create and manage Jira issues using the Jira REST API or MCP.
+
+## Setup
+
+### Option 1: Jira MCP Server
+Install the Jira MCP server for seamless integration:
+```bash
+npx @anthropic/create-mcp-server jira
+```
+
+### Option 2: Direct API
+Set environment variables:
+```bash
+export JIRA_BASE_URL="https://yourcompany.atlassian.net"
+export JIRA_EMAIL="your-email@company.com"
+export JIRA_API_TOKEN="your-api-token"
+```
+
+Get your API token: https://id.atlassian.com/manage-profile/security/api-tokens
+
+## Creating Issues
+
+### Basic Issue
+```python
+import requests
+from requests.auth import HTTPBasicAuth
+import os
+
+def create_issue(project_key, summary, description, issue_type="Task"):
+    url = f"{os.environ['JIRA_BASE_URL']}/rest/api/3/issue"
+
+    auth = HTTPBasicAuth(
+        os.environ['JIRA_EMAIL'],
+        os.environ['JIRA_API_TOKEN']
+    )
+
+    payload = {
+        "fields": {
+            "project": {"key": project_key},
+            "summary": summary,
+            "description": {
+                "type": "doc",
+                "version": 1,
+                "content": [{
+                    "type": "paragraph",
+                    "content": [{"type": "text", "text": description}]
+                }]
+            },
+            "issuetype": {"name": issue_type}
+        }
+    }
+
+    response = requests.post(url, json=payload, auth=auth)
+    return response.json()
+
+# Example
+issue = create_issue("PROJ", "Fix login bug", "Users can't login with SSO", "Bug")
+print(f"Created: {issue['key']}")
+```
+
+### With Labels and Priority
+```python
+def create_detailed_issue(project_key, summary, description,
+                          issue_type="Task", priority="Medium",
+                          labels=None, assignee=None):
+    payload = {
+        "fields": {
+            "project": {"key": project_key},
+            "summary": summary,
+            "description": {
+                "type": "doc",
+                "version": 1,
+                "content": [{
+                    "type": "paragraph",
+                    "content": [{"type": "text", "text": description}]
+                }]
+            },
+            "issuetype": {"name": issue_type},
+            "priority": {"name": priority},
+        }
+    }
+
+    if labels:
+        payload["fields"]["labels"] = labels
+    if assignee:
+        payload["fields"]["assignee"] = {"accountId": assignee}
+
+    # ... make request
+```
+
+## Common Issue Types
+
+| Type | Use For |
+|------|---------|
+| Bug | Something broken |
+| Task | Work item |
+| Story | User-facing feature |
+| Epic | Large initiative |
+| Sub-task | Part of larger task |
+
+## Updating Issues
+
+### Change Status
+```python
+def transition_issue(issue_key, transition_name):
+    # Get available transitions
+    url = f"{JIRA_BASE_URL}/rest/api/3/issue/{issue_key}/transitions"
+    transitions = requests.get(url, auth=auth).json()
+
+    # Find matching transition
+    transition_id = None
+    for t in transitions['transitions']:
+        if t['name'].lower() == transition_name.lower():
+            transition_id = t['id']
+            break
+
+    # Execute transition
+    requests.post(url, json={"transition": {"id": transition_id}}, auth=auth)
+```
+
+### Add Comment
+```python
+def add_comment(issue_key, comment_text):
+    url = f"{JIRA_BASE_URL}/rest/api/3/issue/{issue_key}/comment"
+
+    payload = {
+        "body": {
+            "type": "doc",
+            "version": 1,
+            "content": [{
+                "type": "paragraph",
+                "content": [{"type": "text", "text": comment_text}]
+            }]
+        }
+    }
+
+    requests.post(url, json=payload, auth=auth)
+```
+
+## Searching Issues
+
+### JQL Queries
+```python
+def search_issues(jql):
+    url = f"{JIRA_BASE_URL}/rest/api/3/search"
+    params = {"jql": jql, "maxResults": 50}
+    response = requests.get(url, params=params, auth=auth)
+    return response.json()['issues']
+
+# Examples
+my_bugs = search_issues("project = PROJ AND type = Bug AND assignee = currentUser()")
+open_items = search_issues("project = PROJ AND status != Done")
+recent = search_issues("project = PROJ AND created >= -7d")
+```
+
+## Quick Commands
+
+When user says... create this:
+
+| Command | Action |
+|---------|--------|
+| "log bug about X" | Bug issue with description |
+| "create task for X" | Task issue |
+| "what's on my plate" | JQL: assignee = currentUser() AND status != Done |
+| "move X to done" | Transition issue to Done |
+| "add comment to X" | Add comment to issue |
+
+## Best Practices
+
+1. **Summary**: Keep under 80 chars, start with verb (Fix, Add, Update)
+2. **Description**: Include steps to reproduce for bugs
+3. **Labels**: Use for categorization (frontend, backend, urgent)
+4. **Links**: Reference related issues when relevant