claudeinone-cli 1.0.2 → 1.0.3

package/kit/.claude/skills/patterns-factory-singleton.md

@@ -0,0 +1,209 @@
+# Design Patterns
+
+Common patterns for software architecture.
+
+## Singleton Pattern
+
+```typescript
+// Ensure only one instance exists
+class Logger {
+  private static instance: Logger;
+
+  private constructor() {}
+
+  static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  log(message: string) {
+    console.log(`[LOG] ${message}`);
+  }
+}
+
+// Usage
+const logger1 = Logger.getInstance();
+const logger2 = Logger.getInstance();
+
+console.log(logger1 === logger2); // true
+```
+
+## Factory Pattern
+
+```typescript
+// Create objects without exposing creation logic
+interface Shape {
+  draw(): void;
+}
+
+class Circle implements Shape {
+  draw() { console.log('Drawing circle'); }
+}
+
+class Square implements Shape {
+  draw() { console.log('Drawing square'); }
+}
+
+class ShapeFactory {
+  static createShape(type: string): Shape {
+    switch (type) {
+      case 'circle':
+        return new Circle();
+      case 'square':
+        return new Square();
+      default:
+        throw new Error(`Unknown shape: ${type}`);
+    }
+  }
+}
+
+// Usage
+const circle = ShapeFactory.createShape('circle');
+circle.draw();
+```
+
+## Observer Pattern
+
+```typescript
+// Notify multiple objects about state changes
+interface Observer {
+  update(data: any): void;
+}
+
+class Subject {
+  private observers: Observer[] = [];
+
+  attach(observer: Observer) {
+    this.observers.push(observer);
+  }
+
+  detach(observer: Observer) {
+    const index = this.observers.indexOf(observer);
+    if (index > -1) {
+      this.observers.splice(index, 1);
+    }
+  }
+
+  notify(data: any) {
+    this.observers.forEach(observer => observer.update(data));
+  }
+}
+
+class UserCreatedListener implements Observer {
+  update(data: any) {
+    console.log('User created:', data);
+    // Send welcome email
+  }
+}
+
+// Usage
+const subject = new Subject();
+const listener = new UserCreatedListener();
+
+subject.attach(listener);
+subject.notify({ userId: '123', email: 'user@example.com' });
+```
+
+## Decorator Pattern
+
+```typescript
+// Attach additional responsibilities dynamically
+interface Component {
+  operation(): string;
+}
+
+class ConcreteComponent implements Component {
+  operation(): string {
+    return 'ConcreteComponent';
+  }
+}
+
+abstract class Decorator implements Component {
+  constructor(protected component: Component) {}
+
+  operation(): string {
+    return this.component.operation();
+  }
+}
+
+class ConcreteDecoratorA extends Decorator {
+  operation(): string {
+    return `ConcreteDecoratorA(${super.operation()})`;
+  }
+}
+
+class ConcreteDecoratorB extends Decorator {
+  operation(): string {
+    return `ConcreteDecoratorB(${super.operation()})`;
+  }
+}
+
+// Usage
+const component = new ConcreteComponent();
+const decorated = new ConcreteDecoratorA(
+  new ConcreteDecoratorB(component)
+);
+
+console.log(decorated.operation()); // ConcreteDecoratorA(ConcreteDecoratorB(ConcreteComponent))
+```
+
+## Strategy Pattern
+
+```typescript
+// Define family of interchangeable algorithms
+interface SortStrategy {
+  sort(items: number[]): number[];
+}
+
+class BubbleSort implements SortStrategy {
+  sort(items: number[]): number[] {
+    const arr = [...items];
+    for (let i = 0; i < arr.length; i++) {
+      for (let j = 0; j < arr.length - i - 1; j++) {
+        if (arr[j] > arr[j + 1]) {
+          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+        }
+      }
+    }
+    return arr;
+  }
+}
+
+class QuickSort implements SortStrategy {
+  sort(items: number[]): number[] {
+    if (items.length <= 1) return items;
+    const pivot = items[0];
+    const less = items.slice(1).filter(x => x <= pivot);
+    const greater = items.slice(1).filter(x => x > pivot);
+    return [...this.sort(less), pivot, ...this.sort(greater)];
+  }
+}
+
+class Sorter {
+  constructor(private strategy: SortStrategy) {}
+
+  sort(items: number[]): number[] {
+    return this.strategy.sort(items);
+  }
+}
+
+// Usage
+const items = [3, 1, 4, 1, 5];
+const sorter = new Sorter(new QuickSort());
+console.log(sorter.sort(items)); // [1, 1, 3, 4, 5]
+```
+
+## Best Practices
+
+✅ **Use appropriate patterns** - Don't over-engineer
+✅ **Combine patterns** - Real apps use multiple patterns
+✅ **Document patterns** - Make intent clear
+✅ **Refactor to patterns** - Emerge naturally from code
+✅ **Know the tradeoffs** - Patterns have pros and cons
+
+## Resources
+
+- [Gang of Four Design Patterns](https://en.wikipedia.org/wiki/Design_Patterns)
+- [Refactoring Guru Patterns](https://refactoring.guru/design-patterns)

package/kit/.claude/skills/patterns-observer-pubsub.md

@@ -0,0 +1,210 @@
+# Observer & Pub/Sub Patterns
+
+Decoupled event-driven communication.
+
+## Observer Pattern Implementation
+
+```typescript
+type Observer<T> = (data: T) => void;
+
+class Subject<T> {
+  private observers: Set<Observer<T>> = new Set();
+
+  subscribe(observer: Observer<T>): () => void {
+    this.observers.add(observer);
+    // Return unsubscribe function
+    return () => this.observers.delete(observer);
+  }
+
+  notify(data: T) {
+    this.observers.forEach(observer => observer(data));
+  }
+}
+
+// Usage
+const userSubject = new Subject<{ userId: string; action: string }>();
+
+const unsubscribe1 = userSubject.subscribe(data => {
+  console.log('Email service:', data);
+});
+
+const unsubscribe2 = userSubject.subscribe(data => {
+  console.log('Analytics:', data);
+});
+
+userSubject.notify({ userId: '123', action: 'login' });
+
+// Unsubscribe
+unsubscribe1();
+```
+
+## Pub/Sub with Channels
+
+```typescript
+class PubSub {
+  private channels = new Map<string, Set<Function>>();
+
+  subscribe(channel: string, callback: Function): () => void {
+    if (!this.channels.has(channel)) {
+      this.channels.set(channel, new Set());
+    }
+
+    this.channels.get(channel)!.add(callback);
+
+    return () => {
+      this.channels.get(channel)!.delete(callback);
+    };
+  }
+
+  publish(channel: string, data: any) {
+    const subscribers = this.channels.get(channel);
+    if (subscribers) {
+      subscribers.forEach(callback => callback(data));
+    }
+  }
+}
+
+// Usage
+const pubsub = new PubSub();
+
+pubsub.subscribe('user:created', (user) => {
+  console.log('User created:', user);
+});
+
+pubsub.subscribe('user:created', (user) => {
+  console.log('Send welcome email to:', user.email);
+});
+
+pubsub.publish('user:created', {
+  id: '123',
+  email: 'user@example.com'
+});
+```
+
+## EventEmitter Pattern
+
+```typescript
+import { EventEmitter } from 'events';
+
+class UserService extends EventEmitter {
+  async createUser(userData: any) {
+    const user = await db.users.create(userData);
+
+    // Emit event
+    this.emit('user:created', user);
+    this.emit('user:modified', user);
+
+    return user;
+  }
+
+  async deleteUser(userId: string) {
+    await db.users.delete(userId);
+    this.emit('user:deleted', userId);
+  }
+}
+
+// Usage
+const userService = new UserService();
+
+userService.on('user:created', (user) => {
+  console.log('New user:', user.email);
+  sendWelcomeEmail(user);
+});
+
+userService.on('user:deleted', (userId) => {
+  console.log('User deleted:', userId);
+});
+
+userService.once('user:modified', (user) => {
+  console.log('User first modified:', user);
+});
+
+await userService.createUser({ email: 'user@example.com' });
+```
+
+## Message Queue Pattern
+
+```typescript
+interface Message {
+  id: string;
+  type: string;
+  payload: any;
+  timestamp: Date;
+}
+
+class MessageQueue {
+  private queue: Message[] = [];
+  private subscribers = new Map<string, Function[]>();
+  private processing = false;
+
+  async enqueue(type: string, payload: any) {
+    this.queue.push({
+      id: crypto.randomUUID(),
+      type,
+      payload,
+      timestamp: new Date()
+    });
+
+    this.process();
+  }
+
+  subscribe(type: string, handler: Function) {
+    if (!this.subscribers.has(type)) {
+      this.subscribers.set(type, []);
+    }
+    this.subscribers.get(type)!.push(handler);
+  }
+
+  private async process() {
+    if (this.processing) return;
+
+    this.processing = true;
+
+    while (this.queue.length > 0) {
+      const message = this.queue.shift()!;
+      const handlers = this.subscribers.get(message.type) || [];
+
+      for (const handler of handlers) {
+        try {
+          await handler(message.payload);
+        } catch (error) {
+          console.error(`Error processing message ${message.id}:`, error);
+          // Re-queue failed messages
+          this.queue.push(message);
+        }
+      }
+    }
+
+    this.processing = false;
+  }
+}
+
+// Usage
+const queue = new MessageQueue();
+
+queue.subscribe('email:send', async (payload) => {
+  await emailService.send(payload.to, payload.subject);
+});
+
+queue.subscribe('analytics:track', async (payload) => {
+  await analytics.track(payload);
+});
+
+await queue.enqueue('email:send', {
+  to: 'user@example.com',
+  subject: 'Welcome'
+});
+```
+
+## Best Practices
+
+✅ **Decouple components** - Reduce dependencies
+✅ **Error handling** - Handle failed subscriptions
+✅ **Memory leaks** - Unsubscribe when done
+✅ **Type safety** - Use generics for typed events
+✅ **Debugging** - Log event emissions
+
+## Resources
+
+- [Node.js EventEmitter](https://nodejs.org/api/events.html)
+- [PubSub Pattern](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern)

package/kit/.claude/skills/payment-lemonsqueezy.md

@@ -0,0 +1,101 @@
+# Lemon Squeezy Payments
+
+## Overview
+Lemon Squeezy is a merchant of record payment platform with built-in tax handling, subscriptions, and a simple API.
+
+## Setup
+
+```bash
+npm install @lemonsqueezy/lemonsqueezy.js
+```
+
+```env
+LEMONSQUEEZY_API_KEY=eyJ0...
+LEMONSQUEEZY_STORE_ID=12345
+LEMONSQUEEZY_WEBHOOK_SECRET=whsec_...
+```
+
+## Create Checkout
+
+```typescript
+import { lemonSqueezySetup, createCheckout } from '@lemonsqueezy/lemonsqueezy.js';
+
+lemonSqueezySetup({ apiKey: process.env.LEMONSQUEEZY_API_KEY! });
+
+// app/api/checkout/route.ts
+export async function POST(req: Request) {
+  const { userId, email, variantId } = await req.json();
+
+  const { data, error } = await createCheckout(
+    process.env.LEMONSQUEEZY_STORE_ID!,
+    variantId,
+    {
+      checkoutData: {
+        email,
+        custom: { userId },
+      },
+      checkoutOptions: {
+        embed: false,
+        media: true,
+        logo: true,
+      },
+      productOptions: {
+        redirectUrl: `${process.env.NEXT_PUBLIC_URL}/dashboard?success=true`,
+        receiptThankYouNote: 'Thank you for subscribing!',
+      },
+    }
+  );
+
+  if (error) return Response.json({ error }, { status: 500 });
+  return Response.json({ url: data?.data.attributes.url });
+}
+```
+
+## Webhook Handler
+
+```typescript
+// app/api/webhooks/lemonsqueezy/route.ts
+import crypto from 'crypto';
+
+export async function POST(req: Request) {
+  const rawBody = await req.text();
+  const signature = req.headers.get('x-signature') ?? '';
+
+  const hmac = crypto
+    .createHmac('sha256', process.env.LEMONSQUEEZY_WEBHOOK_SECRET!)
+    .update(rawBody)
+    .digest('hex');
+
+  if (hmac !== signature) {
+    return Response.json({ error: 'Invalid signature' }, { status: 401 });
+  }
+
+  const event = JSON.parse(rawBody);
+  const eventName = event.meta.event_name;
+  const userId = event.meta.custom_data?.userId;
+
+  switch (eventName) {
+    case 'order_created':
+      await prisma.user.update({
+        where: { id: userId },
+        data: { plan: 'pro', planExpiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) }
+      });
+      break;
+    case 'subscription_cancelled':
+      await prisma.user.update({ where: { id: userId }, data: { plan: 'free' } });
+      break;
+  }
+
+  return Response.json({ received: true });
+}
+```
+
+## Best Practices
+- Always verify webhook signatures before processing
+- Store `userId` in checkout `custom_data` to link purchases to users
+- Use Lemon Squeezy's test mode during development
+- Handle `subscription_renewed`, `subscription_expired`, and `subscription_cancelled` events
+
+## Resources
+- [Lemon Squeezy docs](https://docs.lemonsqueezy.com)
+- [@lemonsqueezy/lemonsqueezy.js](https://github.com/lemonSqueezy/lemonsqueezy-js)

package/kit/.claude/skills/payment-square.md

@@ -0,0 +1,178 @@
+# Square Payments
+
+Payment processing platform with in-store and online capabilities.
+
+## Setup
+
+```bash
+npm install square
+```
+
+## Web Payments
+
+```typescript
+import { Client, Environment } from 'square';
+
+const client = new Client({
+  environment: Environment.Production,
+  accessToken: process.env.SQUARE_ACCESS_TOKEN
+});
+
+const paymentsApi = client.paymentsApi;
+
+async function processPayment(sourceId: string, amountInCents: number) {
+  const response = await paymentsApi.createPayment({
+    sourceId,
+    amountMoney: {
+      amount: BigInt(amountInCents),
+      currency: 'USD'
+    },
+    idempotencyKey: crypto.randomUUID()
+  });
+
+  return response.result;
+}
+```
+
+## Web Payments Form
+
+```typescript
+import { SquareWebPaymentUI } from '@square/web-payments-sdk-js';
+
+async function initializeSquare() {
+  const web = window.Square?.web;
+  
+  if (!web) {
+    throw new Error('Square SDK not loaded');
+  }
+
+  const payments = await web.payments({
+    applicationId: process.env.REACT_APP_SQUARE_APP_ID,
+    locationId: process.env.REACT_APP_SQUARE_LOCATION_ID
+  });
+
+  const card = await payments.card();
+  await card.attach('#card-container');
+
+  return { payments, card };
+}
+
+export function CheckoutForm() {
+  const { payments, card } = useSquarePayments();
+
+  async function handlePayment() {
+    try {
+      const result = await card.tokenize();
+
+      if (result.status === 'OK') {
+        const payment = await fetch('/api/square-payment', {
+          method: 'POST',
+          body: JSON.stringify({
+            sourceId: result.token,
+            amount: 9999
+          })
+        }).then(r => r.json());
+
+        alert('Payment successful!');
+      }
+    } catch (error) {
+      console.error('Payment failed:', error);
+    }
+  }
+
+  return (
+    <div>
+      <div id="card-container"></div>
+      <button onClick={handlePayment}>Pay</button>
+    </div>
+  );
+}
+```
+
+## Customers & Cards
+
+```typescript
+const customersApi = client.customersApi;
+const cardsApi = client.cardsApi;
+
+async function createCustomer(email: string, name: string) {
+  const response = await customersApi.createCustomer({
+    email,
+    givenName: name
+  });
+
+  return response.result?.customer;
+}
+
+async function storeCard(customerId: string, sourceId: string) {
+  const response = await cardsApi.createCard({
+    sourceId,
+    customerId
+  });
+
+  return response.result?.card;
+}
+```
+
+## Subscriptions
+
+```typescript
+const subscriptionApi = client.subscriptionsApi;
+
+async function createSubscription(customerId: string, planId: string) {
+  const response = await subscriptionApi.createSubscription({
+    customerId,
+    locationId: process.env.SQUARE_LOCATION_ID,
+    planVariationId: planId,
+    startDate: new Date().toISOString().split('T')[0]
+  });
+
+  return response.result?.subscription;
+}
+```
+
+## Webhooks
+
+```typescript
+import crypto from 'crypto';
+
+app.post('/webhooks/square', express.json(), (req, res) => {
+  const signature = req.header('x-square-hmac-sha256');
+  const body = req.body;
+
+  const hash = crypto
+    .createHmac('sha256', process.env.SQUARE_WEBHOOK_SIGNATURE_KEY)
+    .update(JSON.stringify(body))
+    .digest('base64');
+
+  if (hash !== signature) {
+    return res.status(401).json({ error: 'Invalid signature' });
+  }
+
+  const event = body.data.object;
+
+  switch (body.type) {
+    case 'payment.created':
+      console.log('Payment created:', event);
+      break;
+    case 'payment.updated':
+      console.log('Payment updated:', event);
+      break;
+  }
+
+  res.json({ success: true });
+});
+```
+
+## Best Practices
+
+✅ **Tokenization** - Use Square's secure token generation
+✅ **3D Secure** - Support for additional verification
+✅ **Idempotency** - Generate unique keys for retry safety
+✅ **Webhooks** - Handle payment state changes
+✅ **Testing** - Use Square's test cards
+
+## Resources
+
+- [Square Developer Docs](https://developer.squareup.com/)
+- [Web Payments SDK](https://developer.squareup.com/docs/web-payments/overview)