cursor-anthropic-skills

For a project called 'E-Commerce API' located in `/projects/ecommerce-api`, I need to implement a new payment processing feature that integrates with Stripe. Using the cursor-anthropic-skills framework, I first enable the Anthropic Skills plugin in Cursor's settings and select the 'Payment Processing' skill. I then open the command palette (Cmd+Shift+P) and run 'Skills: Apply Anthropic Skill' with the prompt: 'Implement a Stripe payment processing feature for the E-Commerce API. The feature should include: 1) A `/payments` endpoint that accepts payment intents, 2) Validation for payment details, 3) Error handling for failed transactions, 4) Logging for audit purposes. The codebase is in `/projects/ecommerce-api` and uses Express.js with TypeScript.'

The AI generates the following code structure:
```typescript
// src/routes/payments.ts
import express from 'express';
import Stripe from 'stripe';
import { validatePaymentRequest } from '../validators/paymentValidator';
import { logPaymentEvent } from '../services/paymentLogger';

const router = express.Router();
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2023-10-16',
});

router.post('/payments', async (req, res) => {
  try {
    const { amount, currency, paymentMethodId, customerEmail } = req.body;

    // Validate input
    const validationResult = validatePaymentRequest({ amount, currency, paymentMethodId });
    if (!validationResult.valid) {
      return res.status(400).json({ error: validationResult.error });
    }

    // Create payment intent
    const paymentIntent = await stripe.paymentIntents.create({
      amount: amount * 100, // Convert to cents
      currency,
      payment_method: paymentMethodId,
      customer_email: customerEmail,
      automatic_payment_methods: { enabled: true },
    });

    // Log the payment attempt
    await logPaymentEvent({
      event: 'payment_intent_created',
      paymentIntentId: paymentIntent.id,
      amount,
      status: paymentIntent.status,
    });

    res.json({
      clientSecret: paymentIntent.client_secret,
      paymentIntentId: paymentIntent.id,
    });
  } catch (error) {
    console.error('Payment processing error:', error);
    await logPaymentEvent({
      event: 'payment_error',
      error: error instanceof Error ? error.message : 'Unknown error',
    });
    res.status(500).json({ error: 'Payment processing failed' });
  }
});

export default router;
```

The AI also provides a test case:
```typescript
// tests/payments.test.ts
import request from 'supertest';
import app from '../src/app';
import { mockStripe } from '../__mocks__/stripe';

describe('Payment Processing', () => {
  beforeEach(() => {
    mockStripe();
  });

  it('should create a payment intent with valid data', async () => {
    const response = await request(app)
      .post('/payments')
      .send({
        amount: 1000,
        currency: 'usd',
        paymentMethodId: 'pm_card_visa',
        customerEmail: 'user@example.com',
      });

    expect(response.status).toBe(200);
    expect(response.body.clientSecret).toBeDefined();
    expect(response.body.paymentIntentId).toMatch(/pi_*/);
  });

  it('should reject invalid payment requests', async () => {
    const response = await request(app)
      .post('/payments')
      .send({
        amount: -100,
        currency: 'invalid',
        paymentMethodId: '',
      });

    expect(response.status).toBe(400);
    expect(response.body.error).toBeDefined();
  });
});
```

Finally, the AI suggests next steps: 1) Add the route to the Express app in `src/app.ts`, 2) Set up environment variables for Stripe keys, 3) Run the tests to verify the implementation, and 4) Deploy the changes to the staging environment for further testing.