claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/backend-rust.md

@@ -0,0 +1,182 @@
+# Rust
+
+Systems language with memory safety without garbage collection, ideal for performance-critical applications.
+
+## Basic Syntax
+
+```rust
+fn main() {
+    let x = 5;              // immutable
+    let mut y = 5;          // mutable
+    y += 1;
+    
+    let s = String::from("hello");
+    println!("{}", s);
+}
+```
+
+## Ownership & Borrowing
+
+```rust
+// Ownership
+let s1 = String::from("hello");
+let s2 = s1;  // s1 no longer valid
+
+// Borrowing (references)
+let s1 = String::from("hello");
+let len = calculate_length(&s1);  // borrow, don't take ownership
+
+fn calculate_length(s: &String) -> usize {
+    s.len()
+}
+
+// Mutable borrow
+let mut s = String::from("hello");
+change_string(&mut s);
+
+fn change_string(s: &mut String) {
+    s.push_str(" world");
+}
+```
+
+## Result & Error Handling
+
+```rust
+use std::fs::File;
+use std::io::Read;
+
+fn read_file(path: &str) -> Result<String, std::io::Error> {
+    let mut file = File::open(path)?;  // propagate error
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    Ok(contents)
+}
+
+// Match on Result
+match read_file("file.txt") {
+    Ok(content) => println!("{}", content),
+    Err(e) => eprintln!("Error: {}", e),
+}
+```
+
+## Web Server with Actix
+
+```rust
+use actix_web::{web, App, HttpServer, HttpResponse};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct User {
+    id: u32,
+    name: String,
+}
+
+async fn get_user(id: web::Path<u32>) -> HttpResponse {
+    let user = User {
+        id: id.into_inner(),
+        name: "John".to_string(),
+    };
+    HttpResponse::Ok().json(user)
+}
+
+async fn create_user(user: web::Json<User>) -> HttpResponse {
+    HttpResponse::Created().json(user.into_inner())
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| {
+        App::new()
+            .route("/users/{id}", web::get().to(get_user))
+            .route("/users", web::post().to(create_user))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+```
+
+## Traits & Generics
+
+```rust
+trait Drawable {
+    fn draw(&self);
+}
+
+struct Circle {
+    radius: f64,
+}
+
+impl Drawable for Circle {
+    fn draw(&self) {
+        println!("Drawing circle with radius {}", self.radius);
+    }
+}
+
+// Generics
+fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
+    let mut largest = list[0];
+    for &item in list {
+        if item > largest {
+            largest = item;
+        }
+    }
+    largest
+}
+```
+
+## Async/Await
+
+```rust
+use tokio::task;
+
+async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
+    let response = reqwest::get(url).await?;
+    response.text().await
+}
+
+#[tokio::main]
+async fn main() {
+    let data = fetch_data("https://api.example.com/data").await;
+    match data {
+        Ok(body) => println!("{}", body),
+        Err(e) => eprintln!("Error: {}", e),
+    }
+}
+```
+
+## Testing
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_addition() {
+        assert_eq!(2 + 2, 4);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_panic() {
+        panic!("This test panics");
+    }
+}
+```
+
+## Best Practices
+
+1. **Leverage the type system**
+2. **Use Option/Result for safety**
+3. **Write idiomatic Rust code**
+4. **Use lifetimes correctly**
+5. **Implement proper error handling**
+6. **Use async/await for concurrency**
+7. **Write comprehensive tests**
+
+## Resources
+
+- [The Rust Book](https://doc.rust-lang.org/book/)
+- [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
+- [Actix Documentation](https://actix.rs/)

package/kit/.claude/skills/backend-websockets.md

@@ -0,0 +1,392 @@
+# WebSockets
+
+Bidirectional real-time communication between client and server.
+
+## Setup with ws Library
+
+```bash
+npm install ws
+npm install -D @types/ws  # TypeScript
+```
+
+## Basic Server
+
+```javascript
+const WebSocket = require('ws');
+const http = require('http');
+
+const server = http.createServer();
+const wss = new WebSocket.Server({ server });
+
+wss.on('connection', (ws) => {
+  console.log('Client connected');
+
+  // Send message to client
+  ws.send(JSON.stringify({ type: 'welcome', message: 'Connected to server' }));
+
+  // Receive messages from client
+  ws.on('message', (data) => {
+    try {
+      const message = JSON.parse(data);
+      console.log('Received:', message);
+
+      // Broadcast to all connected clients
+      wss.clients.forEach((client) => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(JSON.stringify({ type: 'broadcast', data: message }));
+        }
+      });
+    } catch (err) {
+      console.error('Invalid message:', err);
+    }
+  });
+
+  // Handle client disconnect
+  ws.on('close', () => {
+    console.log('Client disconnected');
+  });
+
+  // Handle errors
+  ws.on('error', (error) => {
+    console.error('WebSocket error:', error);
+  });
+});
+
+server.listen(3000, () => {
+  console.log('WebSocket server listening on port 3000');
+});
+```
+
+## Browser Client
+
+```javascript
+const ws = new WebSocket('ws://localhost:3000');
+
+// Connection opened
+ws.onopen = () => {
+  console.log('Connected to server');
+  ws.send(JSON.stringify({ type: 'greeting', name: 'John' }));
+};
+
+// Receive messages
+ws.onmessage = (event) => {
+  const message = JSON.parse(event.data);
+  console.log('Received:', message);
+
+  if (message.type === 'welcome') {
+    console.log(message.message);
+  }
+};
+
+// Connection closed
+ws.onclose = () => {
+  console.log('Disconnected from server');
+};
+
+// Error handling
+ws.onerror = (error) => {
+  console.error('WebSocket error:', error);
+};
+
+// Send message to server
+function sendMessage(msg) {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'message', text: msg }));
+  }
+}
+```
+
+## With Socket.io (Higher-Level)
+
+```bash
+npm install socket.io express
+```
+
+```javascript
+const express = require('express');
+const { createServer } = require('http');
+const { Server } = require('socket.io');
+
+const app = express();
+const server = createServer(app);
+const io = new Server(server, {
+  cors: { origin: '*' }
+});
+
+io.on('connection', (socket) => {
+  console.log(`User ${socket.id} connected`);
+
+  // Send to specific socket
+  socket.emit('welcome', { message: 'Welcome!' });
+
+  // Receive custom event
+  socket.on('message', (data) => {
+    console.log('Message:', data);
+
+    // Broadcast to all clients
+    io.emit('broadcast', {
+      from: socket.id,
+      text: data.text
+    });
+  });
+
+  // Receive message from specific room
+  socket.on('join-room', (room) => {
+    socket.join(room);
+    socket.to(room).emit('user-joined', { userId: socket.id });
+  });
+
+  socket.on('room-message', (data) => {
+    io.to(data.room).emit('new-message', {
+      from: socket.id,
+      text: data.text
+    });
+  });
+
+  socket.on('disconnect', () => {
+    console.log(`User ${socket.id} disconnected`);
+  });
+});
+
+server.listen(3000, () => {
+  console.log('Server listening on port 3000');
+});
+```
+
+## Socket.io Browser Client
+
+```html
+<script src="/socket.io/socket.io.js"></script>
+<script>
+  const socket = io();
+
+  socket.on('connect', () => {
+    console.log('Connected:', socket.id);
+  });
+
+  socket.on('welcome', (data) => {
+    console.log(data.message);
+  });
+
+  socket.on('broadcast', (data) => {
+    console.log(`Message from ${data.from}:`, data.text);
+  });
+
+  // Join room
+  socket.emit('join-room', 'general');
+
+  // Send room message
+  function sendToRoom(room, text) {
+    socket.emit('room-message', { room, text });
+  }
+
+  socket.on('disconnect', () => {
+    console.log('Disconnected');
+  });
+</script>
+```
+
+## Chat Application Example
+
+```javascript
+// Server
+const wss = new WebSocket.Server({ server });
+const rooms = new Map(); // roomId -> Set of users
+
+wss.on('connection', (ws) => {
+  let currentRoom = null;
+  let username = null;
+
+  ws.on('message', (data) => {
+    const message = JSON.parse(data);
+
+    switch (message.type) {
+      case 'join':
+        currentRoom = message.room;
+        username = message.username;
+
+        if (!rooms.has(currentRoom)) {
+          rooms.set(currentRoom, new Set());
+        }
+        rooms.get(currentRoom).add(ws);
+
+        // Notify others in room
+        broadcast(currentRoom, {
+          type: 'user-joined',
+          username: username,
+          usersInRoom: rooms.get(currentRoom).size
+        });
+        break;
+
+      case 'chat':
+        broadcast(currentRoom, {
+          type: 'message',
+          username: username,
+          text: message.text,
+          timestamp: new Date().toISOString()
+        });
+        break;
+
+      case 'typing':
+        broadcast(currentRoom, {
+          type: 'user-typing',
+          username: username
+        }, ws);
+        break;
+    }
+  });
+
+  ws.on('close', () => {
+    if (currentRoom) {
+      rooms.get(currentRoom).delete(ws);
+      broadcast(currentRoom, {
+        type: 'user-left',
+        username: username,
+        usersInRoom: rooms.get(currentRoom).size
+      });
+    }
+  });
+});
+
+function broadcast(room, message, exclude = null) {
+  const clients = rooms.get(room) || new Set();
+  const data = JSON.stringify(message);
+
+  clients.forEach((client) => {
+    if (client !== exclude && client.readyState === WebSocket.OPEN) {
+      client.send(data);
+    }
+  });
+}
+```
+
+## With TypeScript
+
+```typescript
+import WebSocket from 'ws';
+
+interface Message {
+  type: string;
+  [key: string]: any;
+}
+
+const wss = new WebSocket.Server({ port: 3000 });
+
+wss.on('connection', (ws: WebSocket) => {
+  ws.on('message', (data: string) => {
+    try {
+      const message: Message = JSON.parse(data);
+      handleMessage(ws, message);
+    } catch (err) {
+      ws.send(JSON.stringify({ error: 'Invalid JSON' }));
+    }
+  });
+});
+
+function handleMessage(ws: WebSocket, message: Message): void {
+  switch (message.type) {
+    case 'echo':
+      ws.send(JSON.stringify({ type: 'echo', data: message.data }));
+      break;
+  }
+}
+```
+
+## Pub/Sub Pattern
+
+```javascript
+const EventEmitter = require('events');
+const pubsub = new EventEmitter();
+
+wss.on('connection', (ws) => {
+  const subscriptions = new Set();
+
+  ws.on('message', (data) => {
+    const message = JSON.parse(data);
+
+    if (message.type === 'subscribe') {
+      subscriptions.add(message.topic);
+
+      // Subscribe to events
+      const handler = (data) => {
+        ws.send(JSON.stringify({
+          type: 'message',
+          topic: message.topic,
+          data
+        }));
+      };
+
+      pubsub.on(message.topic, handler);
+
+      // Store handler for unsubscribe
+      ws.handlers = ws.handlers || new Map();
+      ws.handlers.set(message.topic, handler);
+    }
+
+    if (message.type === 'publish') {
+      pubsub.emit(message.topic, message.data);
+    }
+  });
+
+  ws.on('close', () => {
+    subscriptions.forEach((topic) => {
+      const handler = ws.handlers.get(topic);
+      pubsub.off(topic, handler);
+    });
+  });
+});
+```
+
+## Best Practices
+
+✅ **Handle disconnections** - Client can lose connection any time
+✅ **Send heartbeats** - Keep connection alive with ping/pong frames
+✅ **Validate messages** - Never trust client data
+✅ **Use acknowledgments** - Wait for client confirmation for important messages
+✅ **Implement reconnection** - Auto-reconnect with exponential backoff
+✅ **Scale with Redis** - For multiple servers, use Redis pub/sub
+✅ **Rate limiting** - Prevent spam from clients
+
+## Scaling with Redis
+
+```javascript
+const redis = require('redis');
+const { createAdapter } = require('@socket.io/redis-adapter');
+
+const redisClient = redis.createClient();
+const pubClient = redisClient.duplicate();
+
+io.adapter(createAdapter(pubClient, pubClient));
+```
+
+## Performance Considerations
+
+- Binary data: Use `binaryType: 'arraybuffer'` for efficient binary transmission
+- Message batching: Send multiple updates in one message
+- Compression: Enable permessage-deflate in production
+- Connection pooling: Limit max connections per IP
+- Memory management: Clean up abandoned connections
+
+## Common Use Cases
+
+✅ Real-time chat applications
+✅ Live notifications
+✅ Collaborative editing (Figma, Google Docs style)
+✅ Live dashboards and monitoring
+✅ Multiplayer games
+✅ Stock price updates
+✅ Live video streams (metadata)
+
+## When NOT to Use WebSockets
+
+❌ Simple one-time requests (use HTTP instead)
+❌ Large file transfers (use streaming APIs)
+❌ When HTTP polling is sufficient
+❌ Browser compatibility needed with old browsers
+
+## Resources
+
+- [WebSocket Standard](https://html.spec.whatwg.org/multipage/web-sockets.html)
+- [ws Library](https://github.com/websockets/ws)
+- [Socket.io](https://socket.io/)
+- [Socket.io Documentation](https://socket.io/docs/)