claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/backend-php-laravel.md

@@ -0,0 +1,156 @@
+# Laravel
+
+PHP framework with elegant syntax for rapid web application development.
+
+## Routes & Controllers
+
+```php
+// routes/web.php
+Route::get('/users/{id}', [UserController::class, 'show']);
+Route::post('/users', [UserController::class, 'store']);
+Route::resource('posts', PostController::class);  // RESTful routes
+
+// app/Http/Controllers/UserController.php
+class UserController extends Controller {
+    public function show($id) {
+        $user = User::findOrFail($id);
+        return view('users.show', ['user' => $user]);
+    }
+    
+    public function store(Request $request) {
+        $validated = $request->validate([
+            'name' => 'required|string',
+            'email' => 'required|email|unique:users',
+        ]);
+        
+        $user = User::create($validated);
+        return redirect('/users/' . $user->id);
+    }
+}
+```
+
+## Eloquent ORM
+
+```php
+// app/Models/User.php
+class User extends Model {
+    protected $fillable = ['name', 'email', 'password'];
+    protected $hidden = ['password'];
+    
+    public function posts() {
+        return $this->hasMany(Post::class);
+    }
+}
+
+// Queries
+$user = User::find(1);
+$user = User::where('email', 'john@example.com')->first();
+$users = User::where('age', '>', 18)->get();
+
+// Relationships
+$user = User::with('posts')->find(1);
+$posts = $user->posts;
+
+// Create/Update
+$user = User::create(['name' => 'John', 'email' => 'john@example.com']);
+$user->update(['name' => 'Jane']);
+$user->delete();
+```
+
+## Migrations & Schema
+
+```php
+// database/migrations/2023_10_01_create_users_table.php
+Schema::create('users', function (Blueprint $table) {
+    $table->id();
+    $table->string('name');
+    $table->string('email')->unique();
+    $table->timestamp('email_verified_at')->nullable();
+    $table->timestamps();
+    $table->index('email');
+});
+```
+
+## Views (Blade)
+
+```blade
+<!-- resources/views/users/show.blade.php -->
+@extends('layouts.app')
+
+@section('content')
+    <h1>{{ $user->name }}</h1>
+    <p>{{ $user->email }}</p>
+    
+    @if($user->posts->count())
+        <ul>
+        @foreach($user->posts as $post)
+            <li>{{ $post->title }}</li>
+        @endforeach
+        </ul>
+    @else
+        <p>No posts yet</p>
+    @endif
+@endsection
+```
+
+## Middleware & Authentication
+
+```php
+// app/Http/Middleware/CheckAdmin.php
+class CheckAdmin {
+    public function handle(Request $request, Closure $next) {
+        if (!auth()->user()?->isAdmin()) {
+            abort(403);
+        }
+        return $next($request);
+    }
+}
+
+// routes/web.php
+Route::middleware('auth', 'admin')->group(function () {
+    Route::delete('/users/{id}', [UserController::class, 'destroy']);
+});
+```
+
+## Validation
+
+```php
+$validated = $request->validate([
+    'name' => 'required|string|max:255',
+    'email' => 'required|email|unique:users',
+    'password' => 'required|confirmed|min:8',
+    'age' => 'integer|min:18',
+]);
+```
+
+## Testing
+
+```php
+class UserTest extends TestCase {
+    public function test_can_create_user() {
+        $response = $this->post('/users', [
+            'name' => 'John',
+            'email' => 'john@example.com',
+        ]);
+        
+        $this->assertDatabaseHas('users', [
+            'email' => 'john@example.com'
+        ]);
+    }
+}
+```
+
+## Best Practices
+
+1. **Use artisan commands**
+2. **Leverage Eloquent relationships**
+3. **Keep controllers clean**
+4. **Use middleware for cross-cutting concerns**
+5. **Write comprehensive tests**
+6. **Use queues for long operations**
+
+## Resources
+
+- [Laravel Documentation](https://laravel.com/docs)
+- [Eloquent ORM](https://laravel.com/docs/eloquent)
+- [Laravel Testing](https://laravel.com/docs/testing)

package/kit/.claude/skills/backend-python-django.md

@@ -0,0 +1,200 @@
+# Django
+
+Batteries-included Python web framework with ORM, admin, and built-in security.
+
+## Models & ORM
+
+```python
+from django.db import models
+
+class User(models.Model):
+    name = models.CharField(max_length=100)
+    email = models.EmailField(unique=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    
+    class Meta:
+        ordering = ['-created_at']
+
+# Queries
+users = User.objects.filter(name__icontains='john')
+user = User.objects.get(id=1)
+User.objects.create(name='Jane', email='jane@example.com')
+user.delete()
+
+# Relations
+class Post(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+    title = models.CharField(max_length=200)
+
+posts = User.objects.filter(id=1).prefetch_related('post_set')
+```
+
+## Views & URLs
+
+```python
+from django.views import View
+from django.http import JsonResponse
+from django.views.decorators.http import require_http_methods
+
+class UserView(View):
+    def get(self, request, user_id):
+        user = User.objects.get(id=user_id)
+        return JsonResponse({'id': user.id, 'name': user.name})
+    
+    def post(self, request):
+        data = json.loads(request.body)
+        user = User.objects.create(**data)
+        return JsonResponse({'id': user.id}, status=201)
+
+# Function-based views
+@require_http_methods(['GET', 'POST'])
+def user_list(request):
+    if request.method == 'GET':
+        users = User.objects.all()
+        return JsonResponse(list(users.values()), safe=False)
+    else:
+        data = json.loads(request.body)
+        user = User.objects.create(**data)
+        return JsonResponse({'id': user.id}, status=201)
+
+# URLs
+from django.urls import path
+urlpatterns = [
+    path('users/<int:user_id>/', UserView.as_view()),
+    path('users/', user_list),
+]
+```
+
+## Forms & Validation
+
+```python
+from django import forms
+
+class UserForm(forms.ModelForm):
+    class Meta:
+        model = User
+        fields = ['name', 'email']
+    
+    def clean_email(self):
+        email = self.cleaned_data['email']
+        if User.objects.filter(email=email).exists():
+            raise forms.ValidationError('Email already exists')
+        return email
+
+# In view
+form = UserForm(request.POST)
+if form.is_valid():
+    form.save()
+else:
+    return JsonResponse(form.errors, status=400)
+```
+
+## Admin Interface
+
+```python
+from django.contrib import admin
+
+@admin.register(User)
+class UserAdmin(admin.ModelAdmin):
+    list_display = ['name', 'email', 'created_at']
+    list_filter = ['created_at']
+    search_fields = ['name', 'email']
+    readonly_fields = ['created_at']
+```
+
+## Middleware & Authentication
+
+```python
+from django.contrib.auth.decorators import login_required
+from django.views.decorators.csrf import csrf_exempt
+
+@login_required
+def protected_view(request):
+    return JsonResponse({'user': request.user.username})
+
+# Middleware
+from django.utils.deprecation import MiddlewareMixin
+
+class CustomMiddleware(MiddlewareMixin):
+    def process_request(self, request):
+        request.custom_data = 'value'
+        return None
+```
+
+## Django REST Framework
+
+```python
+from rest_framework import serializers, viewsets
+from rest_framework.decorators import action
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ['id', 'name', 'email']
+
+class UserViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.all()
+    serializer_class = UserSerializer
+    
+    @action(detail=True, methods=['get'])
+    def recent_posts(self, request, pk=None):
+        user = self.get_object()
+        posts = user.post_set.all()[:5]
+        return Response(PostSerializer(posts, many=True).data)
+
+# Router
+from rest_framework.routers import DefaultRouter
+router = DefaultRouter()
+router.register(r'users', UserViewSet)
+urlpatterns = router.urls
+```
+
+## Database Migrations
+
+```bash
+# Create migration
+python manage.py makemigrations
+
+# Apply migration
+python manage.py migrate
+
+# Show migrations
+python manage.py showmigrations
+
+# Rollback
+python manage.py migrate app 0001
+```
+
+## Testing
+
+```python
+from django.test import TestCase, Client
+
+class UserTests(TestCase):
+    def setUp(self):
+        self.user = User.objects.create(name='John', email='john@example.com')
+    
+    def test_user_creation(self):
+        self.assertEqual(self.user.name, 'John')
+    
+    def test_api_get(self):
+        client = Client()
+        response = client.get(f'/users/{self.user.id}/')
+        self.assertEqual(response.status_code, 200)
+```
+
+## Performance & Best Practices
+
+1. **Use select_related/prefetch_related** for joins
+2. **Index frequently queried fields**
+3. **Use Django ORM, avoid raw SQL**
+4. **Implement proper caching**
+5. **Use Celery for async tasks**
+6. **Implement proper error handling**
+7. **Use middleware for cross-cutting concerns**
+
+## Resources
+
+- [Django Official Docs](https://docs.djangoproject.com/)
+- [Django REST Framework](https://www.django-rest-framework.org/)
+- [Two Scoops of Django](https://www.feldroy.com/books/two-scoops-of-django)

package/kit/.claude/skills/backend-python-fastapi.md

@@ -0,0 +1,169 @@
+# FastAPI
+
+Modern, fast Python web framework for building APIs with automatic documentation and type validation.
+
+## Hello World
+
+```python
+from fastapi import FastAPI
+from typing import Optional
+
+app = FastAPI()
+
+@app.get("/")
+async def read_root():
+    return {"message": "Hello, World!"}
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: int, q: Optional[str] = None):
+    return {"item_id": item_id, "q": q}
+
+# Run: uvicorn main:app --reload
+```
+
+## Request/Response Models (Pydantic)
+
+```python
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    name: str
+    email: str
+    age: Optional[int] = None
+
+@app.post("/users/")
+async def create_user(user: User):
+    return {"created": user}
+
+# Validation happens automatically
+# POST /users/ with invalid data returns 422 error
+```
+
+## Path Parameters, Query Parameters
+
+```python
+@app.get("/users/{user_id}")
+async def read_user(
+    user_id: int,              # Path parameter
+    skip: int = 0,             # Query parameter with default
+    limit: int = 10,
+    search: Optional[str] = None
+):
+    return {"user_id": user_id, "skip": skip, "limit": limit}
+```
+
+## Request Body
+
+```python
+@app.post("/users/")
+async def create_user(user: User):
+    # user is automatically parsed and validated
+    # Returns 422 if validation fails
+    return user
+
+# With multiple body parameters
+class Item(BaseModel):
+    name: str
+    price: float
+
+@app.post("/purchases/")
+async def create_purchase(user: User, item: Item):
+    return {"user": user, "item": item}
+```
+
+## Status Codes & Headers
+
+```python
+from fastapi import status
+
+@app.post("/users/", status_code=status.HTTP_201_CREATED)
+async def create_user(user: User):
+    return user
+
+@app.get("/items/", response_model=List[Item])
+async def list_items():
+    return [Item(name="item1", price=10)]
+```
+
+## Dependencies & Middleware
+
+```python
+from fastapi import Depends, Header
+
+async def verify_token(token: str = Header(...)):
+    if token != "secret":
+        raise Exception("Invalid token")
+    return token
+
+@app.get("/protected")
+async def protected_route(token: str = Depends(verify_token)):
+    return {"token": token}
+
+# Database dependency
+async def get_db():
+    db = Database()
+    try:
+        yield db
+    finally:
+        await db.close()
+
+@app.get("/users")
+async def list_users(db = Depends(get_db)):
+    return await db.users.all()
+```
+
+## Exception Handling
+
+```python
+from fastapi import HTTPException
+
+@app.get("/users/{user_id}")
+async def read_user(user_id: int):
+    user = await db.users.get(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@app.exception_handler(ValueError)
+async def value_error_handler(request, exc):
+    return JSONResponse(
+        status_code=400,
+        content={"detail": str(exc)},
+    )
+```
+
+## Automatic Documentation
+
+FastAPI automatically generates OpenAPI docs:
+- **Swagger UI**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+- **OpenAPI JSON**: http://localhost:8000/openapi.json
+
+## Best Practices
+
+1. **Use type hints**: Enables validation and docs
+2. **Async by default**: Use async functions for better performance
+3. **Pydantic models**: For request/response validation
+4. **Dependencies**: For reusable logic (auth, DB access)
+5. **Logging**: Use Python's logging module
+6. **Testing**: pytest with TestClient
+
+## Testing
+
+```python
+from fastapi.testclient import TestClient
+
+client = TestClient(app)
+
+def test_read_root():
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello, World!"}
+```
+
+## Resources
+
+- [FastAPI Docs](https://fastapi.tiangolo.com/)
+- [Pydantic Validation](https://docs.pydantic.dev/)
+- [Async Python](https://docs.python.org/3/library/asyncio.html)

package/kit/.claude/skills/backend-ruby-rails.md

@@ -0,0 +1,190 @@
+# Ruby on Rails
+
+Convention-over-configuration framework for rapid web application development.
+
+## Scaffolding & Models
+
+```bash
+rails generate scaffold User name:string email:string age:integer
+```
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  has_many :posts
+  validates :name, :email, presence: true
+  validates :email, uniqueness: true
+  
+  before_save :downcase_email
+  
+  def full_email
+    "#{name} <#{email}>"
+  end
+  
+  private
+  
+  def downcase_email
+    self.email = email.downcase
+  end
+end
+```
+
+## Routes & Controllers
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  resources :users
+  resources :posts do
+    resources :comments
+  end
+  
+  get 'dashboard', to: 'dashboard#index'
+  post 'login', to: 'sessions#create'
+end
+
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  before_action :set_user, only: [:show, :edit, :update, :destroy]
+  
+  def index
+    @users = User.all
+  end
+  
+  def show
+    @posts = @user.posts
+  end
+  
+  def create
+    @user = User.new(user_params)
+    if @user.save
+      redirect_to @user, notice: 'User created'
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+  
+  private
+  
+  def set_user
+    @user = User.find(params[:id])
+  end
+  
+  def user_params
+    params.require(:user).permit(:name, :email, :age)
+  end
+end
+```
+
+## Views (ERB)
+
+```erb
+<!-- app/views/users/show.html.erb -->
+<h1><%= @user.name %></h1>
+<p><%= @user.email %></p>
+
+<h2>Posts</h2>
+<% if @user.posts.any? %>
+  <ul>
+    <% @user.posts.each do |post| %>
+      <li><%= link_to post.title, post %></li>
+    <% end %>
+  </ul>
+<% else %>
+  <p>No posts yet</p>
+<% end %>
+
+<%= link_to 'Edit', edit_user_path(@user) %>
+<%= link_to 'Delete', user_path(@user), method: :delete, data: { confirm: 'Are you sure?' } %>
+```
+
+## ActiveRecord Queries
+
+```ruby
+# Find
+user = User.find(1)
+user = User.find_by(email: 'john@example.com')
+users = User.where(age: 18..65)
+
+# Create
+user = User.create(name: 'John', email: 'john@example.com')
+user = User.new(name: 'Jane')
+user.save
+
+# Update
+user.update(name: 'Jane')
+User.update_all(verified: true)
+
+# Delete
+user.destroy
+User.delete_all
+
+# Eager loading
+users = User.includes(:posts)
+users = User.preload(:posts)
+
+# Aggregation
+User.count
+User.group(:age).count
+User.where('age > ?', 18).average(:age)
+```
+
+## Background Jobs (Active Job)
+
+```ruby
+class WelcomeEmailJob < ApplicationJob
+  queue_as :default
+  
+  def perform(user)
+    UserMailer.welcome(user).deliver_later
+  end
+end
+
+# Queue the job
+WelcomeEmailJob.perform_later(user)
+WelcomeEmailJob.set(wait: 1.hour).perform_later(user)
+```
+
+## Testing with RSpec
+
+```ruby
+require 'rails_helper'
+
+RSpec.describe User, type: :model do
+  it { should validate_presence_of(:name) }
+  it { should validate_uniqueness_of(:email) }
+  
+  describe '#full_email' do
+    it 'returns formatted email' do
+      user = User.create(name: 'John', email: 'john@example.com')
+      expect(user.full_email).to eq('John <john@example.com>')
+    end
+  end
+end
+
+RSpec.describe UsersController, type: :controller do
+  describe 'GET #show' do
+    it 'returns the user' do
+      user = User.create(name: 'John', email: 'john@example.com')
+      get :show, params: { id: user.id }
+      expect(response).to be_successful
+    end
+  end
+end
+```
+
+## Best Practices
+
+1. **Use generators for scaffolding**
+2. **Keep models fat, controllers thin**
+3. **Use scopes for common queries**
+4. **Implement proper validations**
+5. **Use background jobs for heavy operations**
+6. **Write comprehensive tests**
+7. **Use migrations for schema changes**
+
+## Resources
+
+- [Rails Guides](https://guides.rubyonrails.org/)
+- [Active Record Documentation](https://guides.rubyonrails.org/active_record_basics.html)
+- [Rails Testing Guide](https://guides.rubyonrails.org/testing.html)