claudeinone-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,414 @@
+# .NET / C#
+
+Modern server-side development with strong typing, high performance, and excellent tooling.
+
+## Setup
+
+```bash
+dotnet new webapi -n MyApi
+cd MyApi
+dotnet add package Microsoft.EntityFrameworkCore.SqlServer
+dotnet add package Serilog.AspNetCore
+```
+
+## ASP.NET Core Project Structure
+
+```csharp
+// Program.cs - Entry point and DI configuration
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to DI container
+builder.Services.AddControllers();
+builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddScoped<IEmailService, EmailService>();
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowAll", p => p.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
+});
+
+var app = builder.Build();
+
+// Configure middleware pipeline
+app.UseHttpsRedirection();
+app.UseCors("AllowAll");
+app.UseAuthorization();
+app.MapControllers();
+
+app.Run();
+```
+
+## Controllers and Dependency Injection
+
+```csharp
+using Microsoft.AspNetCore.Mvc;
+
+[ApiController]
+[Route("api/[controller]")]
+public class UsersController : ControllerBase
+{
+    private readonly IUserService _userService;
+    private readonly ILogger<UsersController> _logger;
+
+    // Constructor injection - dependencies resolved automatically
+    public UsersController(IUserService userService, ILogger<UsersController> logger)
+    {
+        _userService = userService;
+        _logger = logger;
+    }
+
+    [HttpGet("{id}")]
+    public async Task<ActionResult<UserDto>> GetUser(int id)
+    {
+        _logger.LogInformation("Fetching user {UserId}", id);
+
+        var user = await _userService.GetUserAsync(id);
+        if (user == null)
+            return NotFound(new { message = "User not found" });
+
+        return Ok(user);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<UserDto>> CreateUser([FromBody] CreateUserRequest request)
+    {
+        _logger.LogInformation("Creating user with email {Email}", request.Email);
+
+        try
+        {
+            var user = await _userService.CreateUserAsync(request);
+            return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
+        }
+        catch (InvalidOperationException ex)
+        {
+            return BadRequest(new { message = ex.Message });
+        }
+    }
+
+    [HttpPut("{id}")]
+    public async Task<IActionResult> UpdateUser(int id, [FromBody] UpdateUserRequest request)
+    {
+        var updated = await _userService.UpdateUserAsync(id, request);
+        if (!updated)
+            return NotFound();
+
+        return NoContent();
+    }
+
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> DeleteUser(int id)
+    {
+        var deleted = await _userService.DeleteUserAsync(id);
+        if (!deleted)
+            return NotFound();
+
+        return NoContent();
+    }
+}
+```
+
+## Entity Framework Core (ORM)
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+
+// Entity models with relationships
+public class User
+{
+    public int Id { get; set; }
+    [Required]
+    [EmailAddress]
+    public string Email { get; set; } = string.Empty;
+
+    public string Name { get; set; } = string.Empty;
+    public string PasswordHash { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime? LastLogin { get; set; }
+
+    // Navigation property
+    public ICollection<Post> Posts { get; set; } = new List<Post>();
+    public ICollection<Comment> Comments { get; set; } = new List<Comment>();
+}
+
+public class Post
+{
+    public int Id { get; set; }
+    public string Title { get; set; } = string.Empty;
+    public string Content { get; set; } = string.Empty;
+    public bool Published { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    public int UserId { get; set; }
+    public User User { get; set; } = null!;
+
+    public ICollection<Comment> Comments { get; set; } = new List<Comment>();
+}
+
+public class Comment
+{
+    public int Id { get; set; }
+    public string Content { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    public int UserId { get; set; }
+    public User User { get; set; } = null!;
+
+    public int PostId { get; set; }
+    public Post Post { get; set; } = null!;
+}
+
+// DbContext with fluent configuration
+public class AppDbContext : DbContext
+{
+    public DbSet<User> Users { get; set; }
+    public DbSet<Post> Posts { get; set; }
+    public DbSet<Comment> Comments { get; set; }
+
+    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        // User configuration
+        modelBuilder.Entity<User>()
+            .HasIndex(u => u.Email)
+            .IsUnique();
+
+        modelBuilder.Entity<User>()
+            .HasMany(u => u.Posts)
+            .WithOne(p => p.User)
+            .HasForeignKey(p => p.UserId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        // Post configuration
+        modelBuilder.Entity<Post>()
+            .HasIndex(p => new { p.UserId, p.Published });
+
+        modelBuilder.Entity<Post>()
+            .HasMany(p => p.Comments)
+            .WithOne(c => c.Post)
+            .HasForeignKey(c => c.PostId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        // Comment configuration
+        modelBuilder.Entity<Comment>()
+            .HasIndex(c => c.CreatedAt);
+    }
+}
+
+// Service layer using EF Core
+public interface IUserService
+{
+    Task<User?> GetUserAsync(int id);
+    Task<User?> GetUserWithPostsAsync(int id);
+    Task<List<User>> SearchUsersAsync(string email);
+    Task<User> CreateUserAsync(CreateUserRequest request);
+    Task<bool> UpdateUserAsync(int id, UpdateUserRequest request);
+    Task<bool> DeleteUserAsync(int id);
+}
+
+public class UserService : IUserService
+{
+    private readonly AppDbContext _context;
+
+    public UserService(AppDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<User?> GetUserAsync(int id)
+    {
+        return await _context.Users.FindAsync(id);
+    }
+
+    public async Task<User?> GetUserWithPostsAsync(int id)
+    {
+        return await _context.Users
+            .Include(u => u.Posts)
+                .ThenInclude(p => p.Comments)
+            .Include(u => u.Comments)
+            .FirstOrDefaultAsync(u => u.Id == id);
+    }
+
+    public async Task<List<User>> SearchUsersAsync(string email)
+    {
+        return await _context.Users
+            .Where(u => u.Email.Contains(email))
+            .OrderByDescending(u => u.CreatedAt)
+            .ToListAsync();
+    }
+
+    public async Task<User> CreateUserAsync(CreateUserRequest request)
+    {
+        // Check if user already exists
+        var existing = await _context.Users.FirstOrDefaultAsync(u => u.Email == request.Email);
+        if (existing != null)
+            throw new InvalidOperationException("User with this email already exists");
+
+        var user = new User
+        {
+            Email = request.Email,
+            Name = request.Name,
+            PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password)
+        };
+
+        _context.Users.Add(user);
+        await _context.SaveChangesAsync();
+        return user;
+    }
+
+    public async Task<bool> UpdateUserAsync(int id, UpdateUserRequest request)
+    {
+        var user = await _context.Users.FindAsync(id);
+        if (user == null)
+            return false;
+
+        user.Name = request.Name ?? user.Name;
+        user.Email = request.Email ?? user.Email;
+
+        await _context.SaveChangesAsync();
+        return true;
+    }
+
+    public async Task<bool> DeleteUserAsync(int id)
+    {
+        var user = await _context.Users.FindAsync(id);
+        if (user == null)
+            return false;
+
+        _context.Users.Remove(user);
+        await _context.SaveChangesAsync();
+        return true;
+    }
+}
+```
+
+## Request/Response DTOs with Validation
+
+```csharp
+using System.ComponentModel.DataAnnotations;
+
+public class CreateUserRequest
+{
+    [Required(ErrorMessage = "Email is required")]
+    [EmailAddress(ErrorMessage = "Invalid email format")]
+    [StringLength(100)]
+    public string Email { get; set; } = string.Empty;
+
+    [Required]
+    [StringLength(100, MinimumLength = 3)]
+    public string Name { get; set; } = string.Empty;
+
+    [Required]
+    [StringLength(100, MinimumLength = 8)]
+    public string Password { get; set; } = string.Empty;
+}
+
+public class UpdateUserRequest
+{
+    [StringLength(100)]
+    public string? Name { get; set; }
+
+    [EmailAddress]
+    public string? Email { get; set; }
+}
+
+public class UserDto
+{
+    public int Id { get; set; }
+    public string Email { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; }
+}
+```
+
+## Global Error Handling
+
+```csharp
+public class ExceptionHandlingMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly ILogger<ExceptionHandlingMiddleware> _logger;
+
+    public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
+    {
+        _next = next;
+        _logger = logger;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await _next(context);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unhandled exception occurred");
+            context.Response.ContentType = "application/json";
+            context.Response.StatusCode = ex switch
+            {
+                NotFoundException => StatusCodes.Status404NotFound,
+                ValidationException => StatusCodes.Status400BadRequest,
+                UnauthorizedAccessException => StatusCodes.Status401Unauthorized,
+                _ => StatusCodes.Status500InternalServerError
+            };
+
+            var response = new { message = ex.Message, type = ex.GetType().Name };
+            await context.Response.WriteAsJsonAsync(response);
+        }
+    }
+}
+
+// Register in Program.cs
+app.UseMiddleware<ExceptionHandlingMiddleware>();
+```
+
+## Database Migrations
+
+```bash
+# Create migration
+dotnet ef migrations add InitialCreate
+
+# Apply migrations to database
+dotnet ef database update
+
+# Revert to previous migration
+dotnet ef migrations remove
+
+# List pending migrations
+dotnet ef migrations list
+
+# Generate SQL script
+dotnet ef migrations script
+```
+
+## Best Practices
+
+✅ **Use async/await** - All I/O operations must be async
+✅ **Constructor injection** - Never use new() for dependencies
+✅ **Validation** - Use DataAnnotations or FluentValidation
+✅ **Logging** - Structured logging with correlation IDs
+✅ **Error handling** - Custom exceptions, middleware for global handling
+✅ **Connection pooling** - Enabled by default, monitor pool size
+✅ **Entity validation** - Validate in service layer, not controller
+✅ **Migrations** - Always track schema changes with EF migrations
+
+## Performance Tips
+
+- Use `.AsNoTracking()` for read-only queries
+- Project queries with `.Select()` instead of loading full entities
+- Enable query caching with Redis
+- Use `DbContextPool` for high-throughput scenarios
+- Monitor N+1 queries with `eager loading` (Include/ThenInclude)
+
+## Resources
+
+- [ASP.NET Core Docs](https://docs.microsoft.com/aspnet/core/)
+- [Entity Framework Core](https://learn.microsoft.com/ef/core/)
+- [C# Language Guide](https://docs.microsoft.com/dotnet/csharp/)

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

@@ -0,0 +1,129 @@
+# Express.js
+
+Minimalist, unopinionated Node.js web framework for building APIs and web applications.
+
+## Basic Setup
+
+```javascript
+const express = require('express');
+const app = express();
+
+// Middleware
+app.use(express.json()); // Parse JSON requests
+app.use(express.static('public')); // Serve static files
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.path}`);
+  next();
+});
+
+// Routes
+app.get('/users', (req, res) => {
+  res.json({ users: [] });
+});
+
+app.post('/users', (req, res) => {
+  const { name } = req.body;
+  res.status(201).json({ id: 1, name });
+});
+
+app.listen(3000, () => console.log('Server running on :3000'));
+```
+
+## Middleware & Routing
+
+### Middleware Chain
+```javascript
+// Execute in order
+app.use(cors());
+app.use(morgan('dev'));
+app.use(express.json());
+app.use(authenticateToken);
+app.use('/api', apiRoutes);
+```
+
+### Router Pattern
+```javascript
+const router = express.Router();
+
+router.get('/:id', (req, res) => {
+  const { id } = req.params;
+  res.json({ id });
+});
+
+router.post('/', (req, res) => {
+  res.status(201).json({ id: 1, ...req.body });
+});
+
+module.exports = router;
+
+// Use in app
+app.use('/users', require('./routes/users'));
+```
+
+## Request/Response Handling
+
+```javascript
+// Request - access data
+app.post('/users', (req, res) => {
+  const { name } = req.body;              // Parse JSON
+  const { page } = req.query;             // Query params
+  const { id } = req.params;              // Route params
+  const token = req.get('authorization'); // Headers
+  
+  // Response
+  res.status(201)
+    .set('Content-Type', 'application/json')
+    .json({ id: 1, name });
+});
+```
+
+## Error Handling
+
+```javascript
+// Try-catch in async routes
+app.get('/users/:id', async (req, res, next) => {
+  try {
+    const user = await db.user.findById(req.params.id);
+    if (!user) return res.status(404).json({ error: 'Not found' });
+    res.json(user);
+  } catch (err) {
+    next(err); // Pass to error handler
+  }
+});
+
+// Error handling middleware (must be last)
+app.use((err, req, res, next) => {
+  console.error(err);
+  res.status(500).json({ error: 'Internal server error' });
+});
+```
+
+## Useful Middleware
+
+```javascript
+const express = require('express');
+const cors = require('cors');
+const morgan = require('morgan');
+const helmet = require('helmet');
+
+app.use(helmet()); // Security headers
+app.use(cors()); // Cross-origin requests
+app.use(morgan('dev')); // Request logging
+app.use(express.json()); // Parse JSON
+app.use(express.urlencoded({ extended: true })); // Form data
+```
+
+## Best Practices
+
+1. **Structure**: Separate routes, controllers, services, models
+2. **Validation**: Validate request data before processing
+3. **Error Handling**: Handle errors consistently
+4. **Logging**: Log important events for debugging
+5. **Security**: Use helmet, validate input, sanitize data
+6. **Performance**: Use async/await, cache where appropriate
+7. **Testing**: Write unit and integration tests
+
+## Resources
+
+- [Express Official Docs](https://expressjs.com/)
+- [RESTful API Design](https://restfulapi.net/)

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

@@ -0,0 +1,104 @@
+# Fastify
+
+Fast and low-overhead Node.js web framework for building APIs with built-in JSON schema validation.
+
+## Basic Setup
+
+```javascript
+const fastify = require('fastify')({ logger: true });
+
+fastify.get('/', async (request, reply) => {
+  return { hello: 'world' };
+});
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err;
+  console.log(`Server listening at ${address}`);
+});
+```
+
+## Schemas & Validation
+
+```javascript
+const schema = {
+  body: {
+    type: 'object',
+    required: ['name', 'email'],
+    properties: {
+      name: { type: 'string' },
+      email: { type: 'string', format: 'email' }
+    }
+  },
+  response: {
+    200: {
+      type: 'object',
+      properties: {
+        id: { type: 'number' },
+        name: { type: 'string' }
+      }
+    }
+  }
+};
+
+fastify.post('/users', { schema }, async (request, reply) => {
+  // Data is validated, typed, and serialized efficiently
+  const user = await db.user.create(request.body);
+  reply.status(201).send(user);
+});
+```
+
+## Plugins & Hooks
+
+```javascript
+// Register plugin
+fastify.register(require('@fastify/cors'));
+fastify.register(require('@fastify/jwt'), { secret: 'secret' });
+
+// Pre-handler hook
+fastify.addHook('preHandler', async (request, reply) => {
+  await request.jwtVerify();
+});
+
+// Route-level hook
+fastify.post('/protected', {
+  onRequest: [fastify.authenticate]
+}, async (request, reply) => {
+  return { user: request.user };
+});
+```
+
+## Error Handling
+
+```javascript
+fastify.setErrorHandler((error, request, reply) => {
+  if (error.validation) {
+    reply.status(400).send({
+      statusCode: 400,
+      error: 'Bad Request',
+      message: error.message
+    });
+  } else {
+    reply.status(500).send({ statusCode: 500, error: 'Internal Server Error' });
+  }
+});
+```
+
+## Performance
+
+- Serializes responses using schema
+- Efficient JSON parsing
+- Built-in compression and caching
+- Zero-copy response generation
+
+## Best Practices
+
+1. Always define schemas for validation
+2. Use TypeScript for type safety
+3. Leverage plugins for common functionality
+4. Implement proper error handling
+5. Monitor performance metrics
+
+## Resources
+
+- [Fastify Documentation](https://www.fastify.io/)
+- [JSON Schema](https://json-schema.org/)