claude-termux 1.0.0

package/skills/finishing-a-development-branch/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: finishing-a-development-branch
+description: Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
+---
+
+# Finishing a Development Branch
+
+## Overview
+
+Guide completion of development work by presenting clear options and handling chosen workflow.
+
+**Core principle:** Verify tests → Present options → Execute choice → Clean up.
+
+**Announce at start:** "I'm using the finishing-a-development-branch skill to complete this work."
+
+## The Process
+
+### Step 1: Verify Tests
+
+**Before presenting options, verify tests pass:**
+
+```bash
+# Run project's test suite
+npm test / cargo test / pytest / go test ./...
+```
+
+**If tests fail:**
+```
+Tests failing (<N> failures). Must fix before completing:
+
+[Show failures]
+
+Cannot proceed with merge/PR until tests pass.
+```
+
+Stop. Don't proceed to Step 2.
+
+**If tests pass:** Continue to Step 2.
+
+### Step 2: Determine Base Branch
+
+```bash
+# Try common base branches
+git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null
+```
+
+Or ask: "This branch split from main - is that correct?"
+
+### Step 3: Present Options
+
+Present exactly these 4 options:
+
+```
+Implementation complete. What would you like to do?
+
+1. Merge back to <base-branch> locally
+2. Push and create a Pull Request
+3. Keep the branch as-is (I'll handle it later)
+4. Discard this work
+
+Which option?
+```
+
+**Don't add explanation** - keep options concise.
+
+### Step 4: Execute Choice
+
+#### Option 1: Merge Locally
+
+```bash
+# Switch to base branch
+git checkout <base-branch>
+
+# Pull latest
+git pull
+
+# Merge feature branch
+git merge <feature-branch>
+
+# Verify tests on merged result
+<test command>
+
+# If tests pass
+git branch -d <feature-branch>
+```
+
+Then: Cleanup worktree (Step 5)
+
+#### Option 2: Push and Create PR
+
+```bash
+# Push branch
+git push -u origin <feature-branch>
+
+# Create PR
+gh pr create --title "<title>" --body "$(cat <<'EOF'
+## Summary
+<2-3 bullets of what changed>
+
+## Test Plan
+- [ ] <verification steps>
+EOF
+)"
+```
+
+Then: Cleanup worktree (Step 5)
+
+#### Option 3: Keep As-Is
+
+Report: "Keeping branch <name>. Worktree preserved at <path>."
+
+**Don't cleanup worktree.**
+
+#### Option 4: Discard
+
+**Confirm first:**
+```
+This will permanently delete:
+- Branch <name>
+- All commits: <commit-list>
+- Worktree at <path>
+
+Type 'discard' to confirm.
+```
+
+Wait for exact confirmation.
+
+If confirmed:
+```bash
+git checkout <base-branch>
+git branch -D <feature-branch>
+```
+
+Then: Cleanup worktree (Step 5)
+
+### Step 5: Cleanup Worktree
+
+**For Options 1, 2, 4:**
+
+Check if in worktree:
+```bash
+git worktree list | grep $(git branch --show-current)
+```
+
+If yes:
+```bash
+git worktree remove <worktree-path>
+```
+
+**For Option 3:** Keep worktree.
+
+## Quick Reference
+
+| Option | Merge | Push | Keep Worktree | Cleanup Branch |
+|--------|-------|------|---------------|----------------|
+| 1. Merge locally | ✓ | - | - | ✓ |
+| 2. Create PR | - | ✓ | ✓ | - |
+| 3. Keep as-is | - | - | ✓ | - |
+| 4. Discard | - | - | - | ✓ (force) |
+
+## Common Mistakes
+
+**Skipping test verification**
+- **Problem:** Merge broken code, create failing PR
+- **Fix:** Always verify tests before offering options
+
+**Open-ended questions**
+- **Problem:** "What should I do next?" → ambiguous
+- **Fix:** Present exactly 4 structured options
+
+**Automatic worktree cleanup**
+- **Problem:** Remove worktree when might need it (Option 2, 3)
+- **Fix:** Only cleanup for Options 1 and 4
+
+**No confirmation for discard**
+- **Problem:** Accidentally delete work
+- **Fix:** Require typed "discard" confirmation
+
+## Red Flags
+
+**Never:**
+- Proceed with failing tests
+- Merge without verifying tests on result
+- Delete work without confirmation
+- Force-push without explicit request
+
+**Always:**
+- Verify tests before offering options
+- Present exactly 4 options
+- Get typed confirmation for Option 4
+- Clean up worktree for Options 1 & 4 only
+
+## Integration
+
+**Called by:**
+- **subagent-driven-development** (Step 7) - After all tasks complete
+- **executing-plans** (Step 5) - After all batches complete
+
+**Pairs with:**
+- **using-git-worktrees** - Cleans up worktree created by that skill

package/skills/frontend-design/frontend-design/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
+license: Complete terms in LICENSE.txt
+---
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

package/skills/integration-testing/SKILL.md

@@ -0,0 +1,13 @@
+integration-testing skill helps verify that different components of the system work together correctly through end-to-end testing and contract testing.
+
+For code review, check that:
+1. Critical user journeys are tested end-to-end
+2. API contracts are tested with provider tests
+3. Database integration is tested
+4. External service integrations are tested
+5. Test data is properly isolated
+6. Tests are deterministic and repeatable
+7. Test environments mimic production
+8. Performance tests cover critical paths
+9. Error scenarios are tested
+10. Test coverage includes all integrations

package/skills/integration-testing/examples/contract-test.py

@@ -0,0 +1,317 @@
+# Provider Contract Test Example
+# Verifies API contract between frontend and backend services
+
+import pytest
+import json
+from pact import Consumer, Provider
+from utils.api_client import APIClient
+from utils.test_data import generate_test_order
+
+# Define contract
+pact = Consumer('WebApp').has_pact_with(Provider('OrderService'))
+
+def test_create_order_contract():
+  """Test contract for creating an order"""
+
+  expected_order = {
+    "id": 12345,
+    "customer_id": "CUST-001",
+    "items": [
+      {
+        "product_id": "PROD-001",
+        "quantity": 2,
+        "price": 29.99
+      }
+    ],
+    "total": 59.98,
+    "status": "pending",
+    "created_at": "2024-01-15T10:30:00Z"
+  }
+
+  (pact
+   .given('customer CUST-001 exists')
+   .upon_receiving('a request to create an order')
+   .with_request(
+       method='POST',
+       path='/api/orders',
+       headers={
+           'Content-Type': 'application/json',
+           'Authorization': pact.term('Bearer .*', 'Bearer token123')
+       },
+       body={
+           'customer_id': 'CUST-001',
+           'items': [
+               {
+                   'product_id': 'PROD-001',
+                   'quantity': 2
+               }
+           ]
+       }
+   )
+   .will_respond_with(
+       status=201,
+       headers={
+           'Content-Type': 'application/json'
+       },
+       body=expected_order
+   ))
+
+  with pact:
+    # Make actual request against mock server
+    client = APIClient(base_url=pact.uri)
+    response = client.create_order({
+      'customer_id': 'CUST-001',
+      'items': [
+        {
+          'product_id': 'PROD-001',
+          'quantity': 2
+        }
+      ]
+    }, headers={
+      'Authorization': 'Bearer token123'
+    })
+
+    # Verify response
+    assert response.status_code == 201
+    assert response.json() == expected_order
+
+def test_get_products_contract():
+  """Test contract for fetching products"""
+
+  expected_products = {
+    "products": [
+      {
+        "id": "PROD-001",
+        "name": "Test Product",
+        "price": 29.99,
+        "stock": 100,
+        "category": "electronics"
+      }
+    ],
+    "pagination": {
+      "page": 1,
+      "per_page": 10,
+      "total": 1,
+      "total_pages": 1
+    }
+  }
+
+  (pact
+   .given('products exist in the database')
+   .upon_receiving('a request to get products list')
+   .with_request(
+       method='GET',
+       path='/api/products',
+       query={
+           'page': '1',
+           'per_page': '10',
+           'category': 'electronics'
+       }
+   )
+   .will_respond_with(
+       status=200,
+       headers={
+           'Content-Type': 'application/json'
+       },
+       body=expected_products
+   ))
+
+  with pact:
+    client = APIClient(base_url=pact.uri)
+    response = client.get_products(
+      page=1,
+      per_page=10,
+      category='electronics'
+    )
+
+    assert response.status_code == 200
+    assert response.json() == expected_products
+
+def test_error_response_contract():
+  """Test contract for error scenarios"""
+
+  error_response = {
+    "error": {
+      "code": "VALIDATION_ERROR",
+      "message": "Invalid input data",
+      "details": [
+        {
+          "field": "email",
+          "message": "Invalid email format"
+        }
+      ]
+    }
+  }
+
+  (pact
+   .upon_receiving('a request with invalid data')
+   .with_request(
+       method='POST',
+       path='/api/users',
+       headers={'Content-Type': 'application/json'},
+       body={
+         'email': 'invalid-email',
+         'name': ''
+       }
+   )
+   .will_respond_with(
+       status=400,
+       headers={'Content-Type': 'application/json'},
+       body=error_response
+   ))
+
+  with pact:
+    client = APIClient(base_url=pact.uri)
+    response = client.create_user({
+      'email': 'invalid-email',
+      'name': ''
+    })
+
+    assert response.status_code == 400
+    assert response.json() == error_response
+
+@pytest.fixture
+def pact_setup(request):
+  """Setup Pact contract testing"""
+
+  # Start mock service
+  pact.start_service()
+
+  # Ensure pact is verified after each test
+  request.addfinalizer(lambda: pact.verify())
+  request.addfinalizer(lambda: pact.stop_service())
+
+class TestAPIIntegration:
+  """Integration tests with real API service"""
+
+  @pytest.mark.integration
+  def test_full_order_flow(self):
+    """Test complete order processing flow"""
+
+    # 1. Create customer
+    customer = APIClient().create_customer({
+      'name': 'Test Customer',
+      'email': 'test@example.com',
+      'address': '123 Test St'
+    })
+    assert customer.status_code == 201
+    customer_id = customer.json()['id']
+
+    # 2. Create order
+    order_data = generate_test_order(customer_id)
+    order = APIClient().create_order(order_data)
+    assert order.status_code == 201
+    order_id = order.json()['id']
+
+    # 3. Process payment
+    payment = APIClient().process_payment({
+      'order_id': order_id,
+      'amount': order.json()['total'],
+      'payment_method': 'credit_card'
+    })
+    assert payment.status_code == 200
+
+    # 4. Verify order status updated
+    updated_order = APIClient().get_order(order_id)
+    assert updated_order.status_code == 200
+    assert updated_order.json()['status'] == 'paid'
+
+    # 5. Trigger shipping
+    shipment = APIClient().create_shipment({
+      'order_id': order_id,
+      'carrier': 'ups',
+      'tracking_number': '1Z9999W99999999999'
+    })
+    assert shipment.status_code == 201
+
+    # 6. Verify final order status
+    final_order = APIClient().get_order(order_id)
+    assert final_order.json()['status'] == 'shipped'
+    assert 'tracking_number' in final_order.json()['shipment']
+
+  @pytest.mark.integration
+  def test_database_transaction_consistency(self):
+    """Test that database transactions are consistent across services"""
+
+    # This test would check that related microservices maintain consistency
+    # Example: When an order is cancelled, inventory is restored and payment is refunded
+
+    # Create order with items
+    order_data = generate_test_order()
+    response = APIClient().create_order(order_data)
+    order_id = response.json()['id']
+
+    # Check inventory reduced
+    for item in order_data['items']:
+      inventory = APIClient().get_inventory(item['product_id'])
+      assert inventory.json()['available'] < 100
+
+    # Cancel order
+    cancel_response = APIClient().cancel_order(order_id)
+    assert cancel_response.status_code == 200
+
+    # Verify inventory restored
+    for item in order_data['items']:
+      inventory = APIClient().get_inventory(item['product_id'])
+      assert inventory.json()['available'] == 100
+
+    # Verify refund processed
+    refund = APIClient().get_refund(order_id)
+    assert refund.json()['status'] == 'processed'
+
+@pytest.mark.contract
+class TestMessageContract:
+  """Test message contracts between services"""
+
+  def test_user_event_contract(self):
+    """Test user event message structure"""
+
+    expected_message = {
+      'event_type': 'user_created',
+      'user_id': 'USR-12345',
+      'timestamp': pact.term(
+        matcher=r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z',
+        generator='2024-01-15T10:30:00Z'
+      ),
+      'data': {
+        'email': 'test@example.com',
+        'name': 'Test User'
+      }
+    }
+
+    (pact
+     .upon_receiving('user created event')
+     .with_request(
+         method='POST',
+         path='/api/events',
+         headers={'Content-Type': 'application/json'},
+         body=expected_message
+     )
+     .will_respond_with(status=202))
+
+  def test_order_status_update_contract(self):
+    """Test order status update message"""
+
+    (pact
+     .given('order 12345 exists')
+     .upon_receiving('order status update')
+     .with_request(
+         method='PATCH',
+         path='/api/orders/12345/status',
+         body={
+           'status': 'shipped',
+           'tracking_number': '1Z9999W99999999999'
+         }
+     )
+     .will_respond_with(
+         status=200,
+         body={
+           'order_id': 12345,
+           'status': 'shipped',
+           'tracking_number': '1Z9999W99999999999',
+           'updated_at': pact.term(
+             matcher=r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z',
+             generator='2024-01-15T11:00:00Z'
+           )
+         }
+     ))