claudeinone-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,205 @@
+# Go
+
+Statically-typed, compiled language for building fast, concurrent backend services.
+
+## Hello World
+
+```go
+package main
+
+import (
+    "fmt"
+    "net/http"
+    "log"
+)
+
+func main() {
+    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+        fmt.Fprintf(w, "Hello, World!")
+    })
+    
+    log.Println("Server listening on :8080")
+    log.Fatal(http.ListenAndServe(":8080", nil))
+}
+```
+
+## HTTP Server with Chi Router
+
+```go
+package main
+
+import (
+    "github.com/go-chi/chi/v5"
+    "encoding/json"
+    "net/http"
+)
+
+type User struct {
+    ID    int    `json:"id"`
+    Name  string `json:"name"`
+    Email string `json:"email"`
+}
+
+func main() {
+    r := chi.NewRouter()
+    
+    r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
+        id := chi.URLParam(r, "id")
+        user := User{ID: 1, Name: "John", Email: "john@example.com"}
+        w.Header().Set("Content-Type", "application/json")
+        json.NewEncoder(w).Encode(user)
+    })
+    
+    r.Post("/users", func(w http.ResponseWriter, r *http.Request) {
+        var user User
+        json.NewDecoder(r.Body).Decode(&user)
+        w.WriteHeader(http.StatusCreated)
+        json.NewEncoder(w).Encode(user)
+    })
+    
+    http.ListenAndServe(":8080", r)
+}
+```
+
+## Goroutines & Concurrency
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "sync"
+)
+
+func worker(id int, jobs <-chan int, results chan<- int) {
+    for j := range jobs {
+        fmt.Println("Worker", id, "processing job", j)
+        results <- j * 2
+    }
+}
+
+func main() {
+    jobs := make(chan int, 100)
+    results := make(chan int, 100)
+    
+    // Start workers
+    for w := 1; w <= 3; w++ {
+        go worker(w, jobs, results)
+    }
+    
+    // Send jobs
+    for j := 1; j <= 9; j++ {
+        jobs <- j
+    }
+    close(jobs)
+    
+    // Collect results
+    for a := 1; a <= 9; a++ {
+        <-results
+    }
+}
+
+// WaitGroup for synchronization
+var wg sync.WaitGroup
+wg.Add(1)
+go func() {
+    defer wg.Done()
+    // work
+}()
+wg.Wait()
+```
+
+## Error Handling
+
+```go
+package main
+
+import (
+    "errors"
+    "fmt"
+)
+
+func divide(a, b float64) (float64, error) {
+    if b == 0 {
+        return 0, errors.New("division by zero")
+    }
+    return a / b, nil
+}
+
+func main() {
+    result, err := divide(10, 0)
+    if err != nil {
+        fmt.Println("Error:", err)
+        return
+    }
+    fmt.Println("Result:", result)
+}
+```
+
+## Database with GORM
+
+```go
+import "gorm.io/gorm"
+
+type User struct {
+    ID    uint
+    Name  string
+    Email string
+}
+
+func main() {
+    db, _ := gorm.Open(postgres.Open("dsn"), &gorm.Config{})
+    
+    // Create
+    db.Create(&User{Name: "John", Email: "john@example.com"})
+    
+    // Read
+    var user User
+    db.First(&user, 1)
+    
+    // Update
+    db.Model(&user).Update("Name", "Jane")
+    
+    // Delete
+    db.Delete(&user)
+    
+    // Query
+    var users []User
+    db.Where("email LIKE ?", "%example.com").Find(&users)
+}
+```
+
+## Testing
+
+```go
+package main
+
+import "testing"
+
+func TestDivide(t *testing.T) {
+    result, err := divide(10, 2)
+    if err != nil {
+        t.Fatalf("Expected no error, got %v", err)
+    }
+    if result != 5 {
+        t.Errorf("Expected 5, got %v", result)
+    }
+}
+```
+
+## Best Practices
+
+1. **Handle errors explicitly**
+2. **Use goroutines for concurrency**
+3. **Leverage strong typing**
+4. **Use interfaces for flexibility**
+5. **Write idiomatic Go code**
+6. **Use context for cancellation**
+7. **Implement proper logging**
+
+## Resources
+
+- [Go Official Docs](https://golang.org/doc/)
+- [Effective Go](https://golang.org/doc/effective_go)
+- [Go by Example](https://gobyexample.com/)

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

@@ -0,0 +1,149 @@
+# GraphQL
+
+Query language for APIs with strongly-typed schema and efficient data fetching.
+
+## Schema Definition
+
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  posts: [Post!]!
+  createdAt: DateTime!
+}
+
+type Post {
+  id: ID!
+  title: String!
+  content: String!
+  author: User!
+  createdAt: DateTime!
+}
+
+type Query {
+  user(id: ID!): User
+  users(limit: Int = 10): [User!]!
+  post(id: ID!): Post
+}
+
+type Mutation {
+  createUser(name: String!, email: String!): User!
+  createPost(title: String!, content: String!): Post!
+}
+```
+
+## Resolvers (Node.js/Apollo)
+
+```javascript
+const resolvers = {
+  Query: {
+    user(parent, args) {
+      return db.users.findById(args.id);
+    },
+    users(parent, args) {
+      return db.users.find().limit(args.limit);
+    },
+  },
+  User: {
+    posts(user) {
+      return db.posts.find({ authorId: user.id });
+    },
+  },
+  Mutation: {
+    createUser(parent, args) {
+      const user = { ...args, id: generateId() };
+      db.users.insert(user);
+      return user;
+    },
+  },
+};
+
+const server = new ApolloServer({ typeDefs, resolvers });
+```
+
+## Queries
+
+```graphql
+# Simple query
+query {
+  user(id: "1") {
+    name
+    email
+  }
+}
+
+# With nested data
+query {
+  user(id: "1") {
+    name
+    posts {
+      title
+      content
+    }
+  }
+}
+
+# With variables
+query GetUser($id: ID!) {
+  user(id: $id) {
+    name
+    email
+  }
+}
+```
+
+## Mutations
+
+```graphql
+mutation {
+  createUser(name: "John", email: "john@example.com") {
+    id
+    name
+    email
+  }
+}
+
+mutation CreatePost($title: String!, $content: String!) {
+  createPost(title: $title, content: $content) {
+    id
+    title
+  }
+}
+```
+
+## Subscriptions (Real-time)
+
+```graphql
+subscription {
+  userCreated {
+    id
+    name
+    email
+  }
+}
+```
+
+## Best Practices
+
+1. **Design efficient schema**
+2. **Implement proper error handling**
+3. **Use DataLoader to prevent N+1 queries**
+4. **Implement authentication/authorization**
+5. **Cache resolved data**
+6. **Write tests for resolvers**
+7. **Version API thoughtfully**
+
+## Advantages
+
+- Strongly typed schema
+- Request exactly what you need
+- Single endpoint
+- Efficient data fetching
+- Self-documenting via introspection
+
+## Resources
+
+- [GraphQL Official](https://graphql.org/)
+- [Apollo Documentation](https://www.apollographql.com/docs/)
+- [GraphQL Best Practices](https://graphql.org/learn/best-practices/)

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

@@ -0,0 +1,382 @@
+# gRPC
+
+High-performance RPC framework using Protocol Buffers for efficient binary serialization.
+
+## Setup
+
+```bash
+npm install @grpc/grpc-js @grpc/proto-loader
+
+# Or with TypeScript
+npm install -D typescript ts-node
+npm install @grpc/grpc-js @grpc/proto-loader
+```
+
+## Protocol Buffer Definition (.proto)
+
+```protobuf
+syntax = "proto3";
+
+package user;
+
+message User {
+  int32 id = 1;
+  string email = 2;
+  string name = 3;
+  int64 created_at = 4;
+}
+
+message GetUserRequest {
+  int32 id = 1;
+}
+
+message CreateUserRequest {
+  string email = 1;
+  string name = 2;
+}
+
+message Empty {}
+
+service UserService {
+  rpc GetUser(GetUserRequest) returns (User);
+  rpc CreateUser(CreateUserRequest) returns (User);
+  rpc ListUsers(Empty) returns (stream User);
+  rpc DeleteUser(GetUserRequest) returns (Empty);
+}
+```
+
+## Server Implementation
+
+```javascript
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+const path = require('path');
+
+// Load .proto file
+const packageDef = protoLoader.loadSync(path.join(__dirname, 'user.proto'), {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+
+const userProto = grpc.loadPackageDefinition(packageDef);
+const userService = userProto.user.UserService;
+
+// In-memory user database (use real DB in production)
+const users = new Map();
+let userIdCounter = 1;
+
+// Service implementation
+const userServiceImpl = {
+  getUser: (call, callback) => {
+    const user = users.get(call.request.id);
+    if (!user) {
+      return callback({
+        code: grpc.status.NOT_FOUND,
+        message: 'User not found'
+      });
+    }
+    callback(null, user);
+  },
+
+  createUser: (call, callback) => {
+    const user = {
+      id: userIdCounter++,
+      email: call.request.email,
+      name: call.request.name,
+      created_at: Date.now()
+    };
+    users.set(user.id, user);
+    callback(null, user);
+  },
+
+  listUsers: (call) => {
+    // Stream all users
+    for (const user of users.values()) {
+      call.write(user);
+    }
+    call.end();
+  },
+
+  deleteUser: (call, callback) => {
+    const deleted = users.delete(call.request.id);
+    if (!deleted) {
+      return callback({
+        code: grpc.status.NOT_FOUND,
+        message: 'User not found'
+      });
+    }
+    callback(null, {});
+  }
+};
+
+// Create and start server
+const server = new grpc.Server();
+server.addService(userService.service, userServiceImpl);
+
+const PORT = 50051;
+server.bindAsync(`0.0.0.0:${PORT}`, grpc.ServerCredentials.createInsecure(), (err) => {
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  console.log(`gRPC server listening on port ${PORT}`);
+  server.start();
+});
+```
+
+## Client Implementation
+
+```javascript
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+const path = require('path');
+
+// Load proto
+const packageDef = protoLoader.loadSync(path.join(__dirname, 'user.proto'), {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true
+});
+
+const userProto = grpc.loadPackageDefinition(packageDef);
+const UserService = userProto.user.UserService;
+
+// Create client
+const client = new UserService('localhost:50051', grpc.credentials.createInsecure());
+
+// Get single user
+client.getUser({ id: 1 }, (err, response) => {
+  if (err) {
+    console.error('Error:', err.message);
+  } else {
+    console.log('User:', response);
+  }
+});
+
+// Create user
+client.createUser({ email: 'john@example.com', name: 'John' }, (err, response) => {
+  if (err) {
+    console.error('Error:', err.message);
+  } else {
+    console.log('Created:', response);
+  }
+});
+
+// Stream users
+const stream = client.listUsers({});
+stream.on('data', (user) => {
+  console.log('User:', user);
+});
+stream.on('error', (err) => {
+  console.error('Stream error:', err.message);
+});
+stream.on('end', () => {
+  console.log('Stream ended');
+});
+
+// Delete user
+client.deleteUser({ id: 1 }, (err) => {
+  if (err) {
+    console.error('Error:', err.message);
+  } else {
+    console.log('Deleted');
+  }
+});
+```
+
+## TypeScript Support
+
+```typescript
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+
+interface User {
+  id: number;
+  email: string;
+  name: string;
+  created_at: number;
+}
+
+interface GetUserRequest {
+  id: number;
+}
+
+// Type-safe service definition
+const UserServiceDef: grpc.ServiceDefinition = {
+  getUser: {
+    path: '/user.UserService/GetUser',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (obj: GetUserRequest) => Buffer.from(JSON.stringify(obj)),
+    requestDeserialize: (buf: Buffer) => JSON.parse(buf.toString()),
+    responseSerialize: (obj: User) => Buffer.from(JSON.stringify(obj)),
+    responseDeserialize: (buf: Buffer) => JSON.parse(buf.toString())
+  }
+};
+
+const server = new grpc.Server();
+server.addService(UserServiceDef, {
+  getUser: (call: grpc.ServerUnaryCall<GetUserRequest, User>, callback: grpc.sendUnaryData<User>) => {
+    const user: User = {
+      id: call.request.id,
+      email: 'user@example.com',
+      name: 'John Doe',
+      created_at: Date.now()
+    };
+    callback(null, user);
+  }
+});
+```
+
+## Error Handling
+
+```javascript
+const handleError = (call, error) => {
+  call.emit('error', {
+    code: grpc.status.INTERNAL,
+    message: error.message
+  });
+};
+
+const userServiceImpl = {
+  getUser: (call, callback) => {
+    try {
+      const user = users.get(call.request.id);
+      if (!user) {
+        return callback({
+          code: grpc.status.NOT_FOUND,
+          message: 'User not found',
+          details: `No user with ID ${call.request.id}`
+        });
+      }
+      callback(null, user);
+    } catch (err) {
+      callback({
+        code: grpc.status.INTERNAL,
+        message: 'Internal server error'
+      });
+    }
+  }
+};
+```
+
+## Bidirectional Streaming
+
+```protobuf
+service ChatService {
+  rpc Chat(stream Message) returns (stream Message);
+}
+
+message Message {
+  string user = 1;
+  string text = 2;
+  int64 timestamp = 3;
+}
+```
+
+```javascript
+const chatServiceImpl = {
+  chat: (call) => {
+    call.on('data', (message) => {
+      console.log(`${message.user}: ${message.text}`);
+
+      // Echo back to client
+      call.write({
+        user: 'Server',
+        text: `Echo: ${message.text}`,
+        timestamp: Date.now()
+      });
+    });
+
+    call.on('end', () => {
+      call.end();
+    });
+
+    call.on('error', (err) => {
+      console.error('Stream error:', err);
+    });
+  }
+};
+```
+
+## Metadata and Context
+
+```javascript
+// Server: Access metadata
+const userServiceImpl = {
+  getUser: (call, callback) => {
+    const metadata = call.metadata.getMap();
+    const authToken = metadata['authorization'];
+
+    if (!authToken) {
+      return callback({
+        code: grpc.status.UNAUTHENTICATED,
+        message: 'Missing authorization'
+      });
+    }
+
+    // Process request
+    callback(null, user);
+  }
+};
+
+// Client: Send metadata
+const metadata = new grpc.Metadata();
+metadata.add('authorization', 'Bearer token123');
+
+client.getUser({ id: 1 }, metadata, (err, response) => {
+  console.log(response);
+});
+```
+
+## Best Practices
+
+✅ **Use Protocol Buffers** - Efficient, versioning-friendly serialization
+✅ **Stream for large data** - Don't send huge responses in single RPC
+✅ **Implement deadlines** - Set timeout contexts for requests
+✅ **Use interceptors** - Logging, authentication, rate limiting
+✅ **Error codes** - Use appropriate gRPC error codes
+✅ **Connection pooling** - Reuse client connections
+✅ **Health checks** - Implement gRPC health checking protocol
+
+## Interceptors
+
+```javascript
+const loggingInterceptor = (options, nextCall) => {
+  return new grpc.InterceptingCall(nextCall(options), {
+    start: (metadata, listener, next) => {
+      console.log(`RPC: ${options.method_definition.path}`);
+      next(metadata, listener);
+    }
+  });
+};
+
+const client = new UserService(
+  'localhost:50051',
+  grpc.credentials.createInsecure(),
+  { interceptors: [loggingInterceptor] }
+);
+```
+
+## When to Use gRPC
+
+✅ Microservices communication
+✅ Real-time bidirectional streaming
+✅ High-performance APIs
+✅ Mobile backends (reduced bandwidth)
+✅ Internal services (not public APIs)
+
+❌ Browser clients (use gRPC-Web)
+❌ Simple REST APIs
+❌ Legacy systems requiring HTTP/1.1
+
+## Resources
+
+- [gRPC Documentation](https://grpc.io/docs/)
+- [Protocol Buffers Guide](https://developers.google.com/protocol-buffers)
+- [gRPC Node.js](https://grpc.io/docs/languages/node/)
+- [gRPC Status Codes](https://grpc.io/docs/guides/status-codes/)