ai-qakit 1.0.0

package/templates/.claude/skills/confluence-integration/confluence-integration.md

@@ -0,0 +1,260 @@
+# Confluence Integration Skill
+
+Expert knowledge for integrating with Confluence REST API to fetch pages, parse content, and extract documentation for test analysis.
+
+## Core Capabilities
+
+### 1. Confluence REST API
+
+**Authentication (same as Jira):**
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/api/v2/..."
+```
+
+**Key Endpoints (API v2):**
+| Endpoint | Description |
+|----------|-------------|
+| `/wiki/api/v2/pages/{id}` | Get page by ID |
+| `/wiki/api/v2/pages/{id}?body-format=storage` | Get page with content |
+| `/wiki/api/v2/pages?title={title}&spaceKey={key}` | Search by title |
+| `/wiki/api/v2/spaces` | List spaces |
+| `/wiki/api/v2/spaces/{id}/pages` | Pages in space |
+| `/wiki/rest/api/content/search?cql=...` | Search with CQL |
+
+**Legacy API v1 (still useful):**
+| Endpoint | Description |
+|----------|-------------|
+| `/wiki/rest/api/content/{id}?expand=body.storage` | Get page content |
+| `/wiki/rest/api/content/{id}/child/page` | Get child pages |
+| `/wiki/rest/api/content/search?cql=...` | CQL search |
+
+### 2. Page Content Format
+
+Confluence uses XHTML Storage Format (similar to HTML):
+
+```xml
+<p>This is a paragraph</p>
+<h1>Heading 1</h1>
+<ul>
+  <li>List item 1</li>
+  <li>List item 2</li>
+</ul>
+<table>
+  <tr><th>Header</th></tr>
+  <tr><td>Cell</td></tr>
+</table>
+<ac:structured-macro ac:name="code">
+  <ac:parameter ac:name="language">javascript</ac:parameter>
+  <ac:plain-text-body><![CDATA[const x = 1;]]></ac:plain-text-body>
+</ac:structured-macro>
+```
+
+### 3. Common Macros
+
+| Macro | Purpose |
+|-------|---------|
+| `ac:structured-macro[code]` | Code block |
+| `ac:structured-macro[info]` | Info panel |
+| `ac:structured-macro[warning]` | Warning panel |
+| `ac:structured-macro[note]` | Note panel |
+| `ac:structured-macro[expand]` | Expandable section |
+| `ac:structured-macro[toc]` | Table of contents |
+| `ac:structured-macro[jira]` | Jira issue link |
+| `ac:structured-macro[status]` | Status label |
+
+### 4. Extracting Jira Links from Confluence
+
+Jira issues in Confluence appear as:
+```xml
+<ac:structured-macro ac:name="jira">
+  <ac:parameter ac:name="key">PROJ-123</ac:parameter>
+</ac:structured-macro>
+```
+
+Or as links:
+```xml
+<a href="https://company.atlassian.net/browse/PROJ-123">PROJ-123</a>
+```
+
+### 5. CQL (Confluence Query Language)
+
+**Common Queries:**
+```
+# Pages in space
+space = "PROJ" AND type = "page"
+
+# Pages with title containing
+title ~ "Test Plan"
+
+# Pages with label
+label = "qa-docs"
+
+# Recently modified
+lastModified >= "2024-01-01"
+
+# By creator
+creator = "john.doe"
+
+# Combined
+space = "PROJ" AND label = "requirements" AND lastModified >= "-30d"
+```
+
+### 6. Page Hierarchy
+
+```javascript
+// Get page with ancestors and children
+const response = await fetch(
+  `${baseUrl}/wiki/rest/api/content/${pageId}?expand=ancestors,children.page`
+);
+
+// Ancestors: parent pages up to root
+// Children: direct child pages
+```
+
+### 7. Extracting Test-Related Content
+
+**Look for these patterns:**
+
+| Pattern | Indicates |
+|---------|-----------|
+| "Test Plan", "Test Cases" | Test documentation |
+| "Requirements", "PRD" | Requirements docs |
+| "Design", "Architecture" | Technical specs |
+| "User Guide", "How to" | User documentation |
+| Tables with "Step", "Expected" | Test case tables |
+| Jira macro | Linked tickets |
+
+### 8. Parsing Storage Format
+
+```javascript
+function parseConfluenceContent(storageFormat) {
+  // Simple regex-based extraction
+  const text = storageFormat
+    .replace(/<[^>]+>/g, ' ')  // Remove HTML tags
+    .replace(/\s+/g, ' ')       // Normalize whitespace
+    .trim();
+  
+  // Extract headings
+  const headings = [];
+  const headingRegex = /<h([1-6])[^>]*>([^<]+)<\/h\1>/g;
+  let match;
+  while ((match = headingRegex.exec(storageFormat)) !== null) {
+    headings.push({ level: match[1], text: match[2] });
+  }
+  
+  // Extract Jira keys
+  const jiraKeys = [];
+  const jiraRegex = /ac:parameter ac:name="key">([A-Z]+-\d+)/g;
+  while ((match = jiraRegex.exec(storageFormat)) !== null) {
+    jiraKeys.push(match[1]);
+  }
+  
+  // Extract tables
+  const tables = [];
+  const tableRegex = /<table[^>]*>([\s\S]*?)<\/table>/g;
+  while ((match = tableRegex.exec(storageFormat)) !== null) {
+    tables.push(parseTable(match[1]));
+  }
+  
+  return { text, headings, jiraKeys, tables };
+}
+```
+
+## API Examples
+
+### Get Page by ID
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/api/v2/pages/123456?body-format=storage"
+```
+
+Response:
+```json
+{
+  "id": "123456",
+  "title": "Test Plan - Feature X",
+  "spaceId": "789",
+  "status": "current",
+  "body": {
+    "storage": {
+      "value": "<p>Test plan content...</p>",
+      "representation": "storage"
+    }
+  },
+  "_links": {
+    "webui": "/spaces/PROJ/pages/123456/Test+Plan+-+Feature+X"
+  }
+}
+```
+
+### Search Pages
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/rest/api/content/search?cql=space=PROJ+AND+title~\"Test+Plan\""
+```
+
+### Get Page Children
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/rest/api/content/123456/child/page"
+```
+
+### Get Page by Space and Title
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/rest/api/content?spaceKey=PROJ&title=Test%20Plan"
+```
+
+## Environment Variables
+
+```bash
+# Can reuse Jira credentials (same Atlassian account)
+CONFLUENCE_BASE_URL="https://yourcompany.atlassian.net"
+CONFLUENCE_EMAIL="$JIRA_EMAIL"
+CONFLUENCE_API_TOKEN="$JIRA_API_TOKEN"
+
+# Or separate if different instance
+CONFLUENCE_BASE_URL="https://confluence.yourcompany.com"
+CONFLUENCE_EMAIL="your.email@company.com"
+CONFLUENCE_API_TOKEN="your-token"
+```
+
+## Linking Jira and Confluence
+
+### Find Confluence Links in Jira
+
+Jira tickets may have Confluence links in:
+1. **Description** - as URLs or smart links
+2. **Comments** - referenced docs
+3. **Custom fields** - "Documentation" field
+4. **Remote links** - linked pages
+
+```bash
+# Get remote links (includes Confluence)
+curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" \
+  "$JIRA_BASE_URL/rest/api/3/issue/PROJ-123/remotelink"
+```
+
+### Find Jira Links in Confluence
+
+Search for pages mentioning a Jira ticket:
+```bash
+curl -s -u "$CONFLUENCE_EMAIL:$CONFLUENCE_API_TOKEN" \
+  "$CONFLUENCE_BASE_URL/wiki/rest/api/content/search?cql=text~\"PROJ-123\""
+```
+
+## Best Practices
+
+1. **Use API v2 when possible** - Better pagination, cleaner responses
+2. **Cache page content** - Confluence pages don't change often
+3. **Respect rate limits** - Add delays between requests
+4. **Parse incrementally** - Large pages can be slow to process
+5. **Handle permissions** - Some pages may be restricted
+
+## Related Commands
+
+- `/qakit:setup/confluence` - Setup Confluence integration
+- `/qakit:confluence/fetch` - Fetch page content
+- `/qakit:confluence/search` - Search for docs
+- `/qakit:jira/analyze` - Includes Confluence links

package/templates/.claude/skills/databases/SKILL.md

@@ -0,0 +1,232 @@
+---
+name: databases
+description: "MongoDB and PostgreSQL database administration. Databases: MongoDB (document store, aggregation, Atlas), PostgreSQL (relational, SQL, psql). Capabilities: schema design, query optimization, indexing, migrations, replication, sharding, backup/restore, user management, performance analysis. Actions: design, query, optimize, migrate, backup, restore, index, shard databases. Keywords: MongoDB, PostgreSQL, SQL, NoSQL, BSON, aggregation pipeline, Atlas, psql, pgAdmin, schema design, index, query optimization, EXPLAIN, replication, sharding, backup, restore, migration, ORM, Prisma, Mongoose, connection pooling, transactions, ACID. Use when: designing database schemas, writing complex queries, optimizing query performance, creating indexes, performing migrations, setting up replication, implementing backup strategies, managing database permissions, troubleshooting slow queries."
+license: MIT
+---
+
+# Databases Skill
+
+Unified guide for working with MongoDB (document-oriented) and PostgreSQL (relational) databases. Choose the right database for your use case and master both systems.
+
+## When to Use This Skill
+
+Use when:
+- Designing database schemas and data models
+- Writing queries (SQL or MongoDB query language)
+- Building aggregation pipelines or complex joins
+- Optimizing indexes and query performance
+- Implementing database migrations
+- Setting up replication, sharding, or clustering
+- Configuring backups and disaster recovery
+- Managing database users and permissions
+- Analyzing slow queries and performance issues
+- Administering production database deployments
+
+## Database Selection Guide
+
+### Choose MongoDB When:
+- Schema flexibility: frequent structure changes, heterogeneous data
+- Document-centric: natural JSON/BSON data model
+- Horizontal scaling: need to shard across multiple servers
+- High write throughput: IoT, logging, real-time analytics
+- Nested/hierarchical data: embedded documents preferred
+- Rapid prototyping: schema evolution without migrations
+
+**Best for:** Content management, catalogs, IoT time series, real-time analytics, mobile apps, user profiles
+
+### Choose PostgreSQL When:
+- Strong consistency: ACID transactions critical
+- Complex relationships: many-to-many joins, referential integrity
+- SQL requirement: team expertise, reporting tools, BI systems
+- Data integrity: strict schema validation, constraints
+- Mature ecosystem: extensive tooling, extensions
+- Complex queries: window functions, CTEs, analytical workloads
+
+**Best for:** Financial systems, e-commerce transactions, ERP, CRM, data warehousing, analytics
+
+### Both Support:
+- JSON/JSONB storage and querying
+- Full-text search capabilities
+- Geospatial queries and indexing
+- Replication and high availability
+- ACID transactions (MongoDB 4.0+)
+- Strong security features
+
+## Quick Start
+
+### MongoDB Setup
+
+```bash
+# Atlas (Cloud) - Recommended
+# 1. Sign up at mongodb.com/atlas
+# 2. Create M0 free cluster
+# 3. Get connection string
+
+# Connection
+mongodb+srv://user:pass@cluster.mongodb.net/db
+
+# Shell
+mongosh "mongodb+srv://cluster.mongodb.net/mydb"
+
+# Basic operations
+db.users.insertOne({ name: "Alice", age: 30 })
+db.users.find({ age: { $gte: 18 } })
+db.users.updateOne({ name: "Alice" }, { $set: { age: 31 } })
+db.users.deleteOne({ name: "Alice" })
+```
+
+### PostgreSQL Setup
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install postgresql postgresql-contrib
+
+# Start service
+sudo systemctl start postgresql
+
+# Connect
+psql -U postgres -d mydb
+
+# Basic operations
+CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT, age INT);
+INSERT INTO users (name, age) VALUES ('Alice', 30);
+SELECT * FROM users WHERE age >= 18;
+UPDATE users SET age = 31 WHERE name = 'Alice';
+DELETE FROM users WHERE name = 'Alice';
+```
+
+## Common Operations
+
+### Create/Insert
+```javascript
+// MongoDB
+db.users.insertOne({ name: "Bob", email: "bob@example.com" })
+db.users.insertMany([{ name: "Alice" }, { name: "Charlie" }])
+```
+
+```sql
+-- PostgreSQL
+INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com');
+INSERT INTO users (name, email) VALUES ('Alice', NULL), ('Charlie', NULL);
+```
+
+### Read/Query
+```javascript
+// MongoDB
+db.users.find({ age: { $gte: 18 } })
+db.users.findOne({ email: "bob@example.com" })
+```
+
+```sql
+-- PostgreSQL
+SELECT * FROM users WHERE age >= 18;
+SELECT * FROM users WHERE email = 'bob@example.com' LIMIT 1;
+```
+
+### Update
+```javascript
+// MongoDB
+db.users.updateOne({ name: "Bob" }, { $set: { age: 25 } })
+db.users.updateMany({ status: "pending" }, { $set: { status: "active" } })
+```
+
+```sql
+-- PostgreSQL
+UPDATE users SET age = 25 WHERE name = 'Bob';
+UPDATE users SET status = 'active' WHERE status = 'pending';
+```
+
+### Delete
+```javascript
+// MongoDB
+db.users.deleteOne({ name: "Bob" })
+db.users.deleteMany({ status: "deleted" })
+```
+
+```sql
+-- PostgreSQL
+DELETE FROM users WHERE name = 'Bob';
+DELETE FROM users WHERE status = 'deleted';
+```
+
+### Indexing
+```javascript
+// MongoDB
+db.users.createIndex({ email: 1 })
+db.users.createIndex({ status: 1, createdAt: -1 })
+```
+
+```sql
+-- PostgreSQL
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_users_status_created ON users(status, created_at DESC);
+```
+
+## Reference Navigation
+
+### MongoDB References
+- **[mongodb-crud.md](references/mongodb-crud.md)** - CRUD operations, query operators, atomic updates
+- **[mongodb-aggregation.md](references/mongodb-aggregation.md)** - Aggregation pipeline, stages, operators, patterns
+- **[mongodb-indexing.md](references/mongodb-indexing.md)** - Index types, compound indexes, performance optimization
+- **[mongodb-atlas.md](references/mongodb-atlas.md)** - Atlas cloud setup, clusters, monitoring, search
+
+### PostgreSQL References
+- **[postgresql-queries.md](references/postgresql-queries.md)** - SELECT, JOINs, subqueries, CTEs, window functions
+- **[postgresql-psql-cli.md](references/postgresql-psql-cli.md)** - psql commands, meta-commands, scripting
+- **[postgresql-performance.md](references/postgresql-performance.md)** - EXPLAIN, query optimization, vacuum, indexes
+- **[postgresql-administration.md](references/postgresql-administration.md)** - User management, backups, replication, maintenance
+
+## Python Utilities
+
+Database utility scripts in `scripts/`:
+- **db_migrate.py** - Generate and apply migrations for both databases
+- **db_backup.py** - Backup and restore MongoDB and PostgreSQL
+- **db_performance_check.py** - Analyze slow queries and recommend indexes
+
+```bash
+# Generate migration
+python scripts/db_migrate.py --db mongodb --generate "add_user_index"
+
+# Run backup
+python scripts/db_backup.py --db postgres --output /backups/
+
+# Check performance
+python scripts/db_performance_check.py --db mongodb --threshold 100ms
+```
+
+## Key Differences Summary
+
+| Feature | MongoDB | PostgreSQL |
+|---------|---------|------------|
+| Data Model | Document (JSON/BSON) | Relational (Tables/Rows) |
+| Schema | Flexible, dynamic | Strict, predefined |
+| Query Language | MongoDB Query Language | SQL |
+| Joins | $lookup (limited) | Native, optimized |
+| Transactions | Multi-document (4.0+) | Native ACID |
+| Scaling | Horizontal (sharding) | Vertical (primary), Horizontal (extensions) |
+| Indexes | Single, compound, text, geo, etc | B-tree, hash, GiST, GIN, etc |
+
+## Best Practices
+
+**MongoDB:**
+- Use embedded documents for 1-to-few relationships
+- Reference documents for 1-to-many or many-to-many
+- Index frequently queried fields
+- Use aggregation pipeline for complex transformations
+- Enable authentication and TLS in production
+- Use Atlas for managed hosting
+
+**PostgreSQL:**
+- Normalize schema to 3NF, denormalize for performance
+- Use foreign keys for referential integrity
+- Index foreign keys and frequently filtered columns
+- Use EXPLAIN ANALYZE to optimize queries
+- Regular VACUUM and ANALYZE maintenance
+- Connection pooling (pgBouncer) for web apps
+
+## Resources
+
+- MongoDB: https://www.mongodb.com/docs/
+- PostgreSQL: https://www.postgresql.org/docs/
+- MongoDB University: https://learn.mongodb.com/
+- PostgreSQL Tutorial: https://www.postgresqltutorial.com/