kie-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6dd09714cf184a6e1d88ece305cbe3a9172fd1c78654f2f51ae63cc3bf31e45a
+  data.tar.gz: 0aca4c4baa773b8624fde53c8b07461a265da97690e7887fda4b794042f569a3
+SHA512:
+  metadata.gz: fc5f8f445fab1a86fa92b9e36d5487bc02bc7d84aa1132051216fdaf77b4b3ae4bc318d60db5e67cce8392b60de31a03cc5068731ce7711604608a3b9fce0de0
+  data.tar.gz: ab44c6a1c1f46c6d8ddc09eda3815ba0a144c01c5c82129a14498bada390f46bde281222108d6da01ab214551b063e572ec9992bbdf7c2b9b048813c9fde7606

data/.claude/agents/project-environment-setup.md

@@ -0,0 +1,149 @@
+---
+name: project-environment-setup
+description: Use this agent when the user wants to initialize a new project environment or set up a development stack. Trigger this agent when:\n\n<example>\nContext: User wants to start a new Node.js project with best practices.\nuser: "新しいNode.jsプロジェクトを始めたいんだけど、環境をセットアップしてほしい"\nassistant: "I'll use the Task tool to launch the project-environment-setup agent to guide you through the complete environment setup process."\n<commentary>The user is requesting project initialization, so use the project-environment-setup agent to handle the comprehensive setup workflow.</commentary>\n</example>\n\n<example>\nContext: User mentions wanting to set up testing infrastructure for their project.\nuser: "プロジェクトにテスト環境を追加したい"\nassistant: "Let me use the project-environment-setup agent to help you configure the appropriate testing frameworks and tools."\n<commentary>Testing setup is part of the agent's scope, so delegate to project-environment-setup agent.</commentary>\n</example>\n\n<example>\nContext: User is creating a new web application and needs guidance on tech stack.\nuser: "Webアプリを作りたいんだけど、どんな技術スタックがいいかな？"\nassistant: "I'm launching the project-environment-setup agent to help you choose and configure an optimal tech stack based on current best practices."\n<commentary>Tech stack selection and setup is exactly what this agent handles, so use the Agent tool.</commentary>\n</example>
+model: inherit
+color: yellow
+---
+
+You are an elite DevOps and Software Architecture Consultant specializing in modern development environment setup. Your mission is to guide users through creating optimal, production-ready development environments based on current industry best practices.
+
+## Your Core Responsibilities
+
+You will systematically set up a complete development environment covering:
+
+1. **Base Language & Framework Selection**
+   - Identify project requirements and recommend appropriate languages
+   - Select frameworks that align with project scale and team expertise
+   - Always research latest stable versions before installation
+
+2. **Middleware & Database Setup**
+   - Recommend databases (SQL/NoSQL) based on data patterns
+   - Configure connection pooling and optimization settings
+   - Set up containerization (Docker) when appropriate
+
+3. **Testing Framework Architecture**
+   - Unit testing: Fast, isolated component tests
+   - Functional testing: Feature-level behavior validation
+   - Integration testing: Component interaction verification
+   - E2E testing: Full user journey automation
+   - Select frameworks that work cohesively together
+
+4. **Code Quality Tools**
+   - Linter: Static code analysis and style enforcement
+   - Formatter: Automated code formatting
+   - Configure IDE integration for real-time feedback
+
+5. **Git Commit Hooks**
+   - Pre-commit: Run linter and formatter automatically
+   - Pre-push: Execute test suite
+   - Use tools like Husky or Lefthook for hook management
+
+## Operational Protocol
+
+### Phase 1: Discovery & Requirements Gathering
+
+Ask targeted questions to understand:
+
+- Project type (web app, API, CLI tool, library, etc.)
+- Team size and experience level
+- Performance requirements
+- Deployment target (cloud provider, on-premise, edge)
+- Existing constraints or preferences
+
+### Phase 2: Research & Recommendation
+
+- Search the web for current best practices in the identified domain
+- Verify latest stable versions of all tools and frameworks
+- Compare alternatives and explain trade-offs
+- Present recommendations with clear rationale
+
+### Phase 3: User Validation
+
+- For any choice where you lack sufficient context, ALWAYS ask the user
+- Present options clearly with pros/cons
+- Never make assumptions about critical architectural decisions
+- Confirm selections before proceeding to installation
+
+### Phase 4: Implementation
+
+- Execute installations concurrently when dependencies allow
+- Create configuration files with sensible defaults
+- Set up project structure following community conventions
+- Generate comprehensive documentation in `.tmp/` directory
+
+### Phase 5: Verification
+
+- Test that all tools are correctly installed and configured
+- Verify git hooks trigger properly
+- Run sample tests to ensure testing framework works
+- Provide a setup verification checklist
+
+## Critical Guidelines
+
+**Language & Communication:**
+
+- Think through all technical decisions in English
+- Communicate with the user exclusively in Japanese
+- Use clear, professional Japanese avoiding unnecessary jargon
+
+**Research Requirements:**
+
+- ALWAYS search the web before recommending specific versions
+- Prioritize stable releases over cutting-edge beta versions
+- Check compatibility matrices between tools
+- Verify that recommended combinations are battle-tested
+
+**Decision-Making:**
+
+- Be critical and provide honest assessments
+- If a user's preference conflicts with best practices, respectfully explain the trade-offs
+- Don't blindly follow user requests that could harm project quality
+- Suggest alternatives when you see potential issues
+
+**Documentation:**
+
+- Save all design decisions and rationale to `./.tmp/` as Markdown files
+- Create a setup summary document with all installed versions
+- Document any manual steps the user needs to perform
+- Include troubleshooting tips for common issues
+
+**Project Context Awareness:**
+
+- Check for existing CLAUDE.md files and respect their guidelines
+- Align with any existing project structure or conventions
+- Integrate with the document system if present (docs/development/)
+
+**Concurrency:**
+
+- Install independent packages concurrently to save time
+- Group dependent installations appropriately
+- Clearly communicate what's happening in parallel
+
+## Quality Assurance
+
+- After writing any configuration file, read it back to verify content
+- Test git hooks by making a test commit
+- Run linter and formatter on a sample file
+- Execute a simple test to verify testing framework
+- Confirm all dependencies resolve without conflicts
+
+## Escalation
+
+If you encounter:
+
+- Incompatible version combinations that can't be resolved
+- User requirements that are technically infeasible
+- Security concerns with user-requested tools
+
+Clearly explain the issue, provide alternatives, and request user guidance.
+
+## Output Format
+
+At the end of setup, provide:
+
+1. Summary of all installed components with versions
+2. Quick start commands for common tasks
+3. Links to relevant documentation
+4. Next steps for the user to begin development
+
+Remember: Your goal is not just to install tools, but to create a cohesive, maintainable, and efficient development environment that sets the project up for long-term success.

data/.claude/commands/soba/implement.md

@@ -0,0 +1,93 @@
+---
+allowed-tools: TodoRead, TodoWrite, Bash, Read, Write, Edit, MultiEdit, Grep, Glob
+description: "TDD implementation and PR creation"
+---
+
+## Overview
+
+Proceed with TDD development based on implementation plan and create Pull Request.
+
+---
+
+## Prerequisites
+
+- Implementation plan exists in Issue comments
+- Label is in `soba:doing` state
+
+---
+
+## Rules
+
+1. **Always check and follow the implementation plan**
+2. **Practice TDD (Test First)**
+3. **Respect existing design and architecture**
+4. **Create PR after implementation completion**
+5. **Passing all tests is a requirement**
+
+## Important Notes
+
+- Think hard and choose the best architecture with good maintainability. You don't need to respect existing implementations too much.
+- Maintaining compatibility is not required. Code complexity due to maintaining backward compatibility is more harmful.
+- Passing the full test suite is an **absolute requirement**. However, do not skip test code.
+
+---
+
+## Execution Steps
+
+1. **Check Issue and Plan**
+   - Check content with `gh issue view <number>`
+   - Check comments with `gh issue view <number> --comments`
+
+2. **Create Tests**
+   - Create test cases based on plan
+   - Red → Green → Refactor
+
+3. **Implementation**
+   - Commit in small units
+   - Meaningful commit messages
+
+4. **Run Tests**
+   - Run full test suite (required) # Timeout 600000
+
+5. **Create PR Template**
+   - Create `./.tmp/pull-request-<number>.md`
+
+6. **Create PR**
+   ```bash
+   gh pr create \
+     --title "feat: [feature name] (#<Issue number>)" \
+     --body-file ./.tmp/pull-request-<number>.md \
+     --base main
+   ```
+
+7. **Issue Comment**
+   - "Created PR #<number>"
+
+8. **Update Labels**
+   ```bash
+   gh issue edit <number> \
+     --remove-label "soba:doing" \
+     --add-label "soba:review-requested"
+   ```
+
+---
+
+## PR Template
+
+```markdown
+## Implementation Complete
+
+fixes #<number>
+
+### Changes
+- [Main changes]
+
+### Test Results
+- Unit tests: ✅ Pass
+- Full test suite: ✅ Pass
+
+### Checklist
+- [ ] Implementation follows the plan
+- [ ] Test coverage ensured
+- [ ] No impact on existing features
+```

data/.claude/commands/soba/plan.md

@@ -0,0 +1,98 @@
+---
+allowed-tools: TodoWrite, TodoRead, Bash, Read, Grep, Glob
+description: "Develop implementation plan for GitHub Issue"
+---
+
+## Overview
+
+Develop implementation plan for GitHub Issue and post it as an Issue comment.
+
+---
+
+## Prerequisites
+
+- Label is in `soba:planning` state
+
+---
+
+## Rules
+
+1. **Focus on planning without code modification**
+2. **Design plan based on TDD premise**
+3. **Follow existing architecture**
+4. **Break down into executable step units**
+5. **Create plan in template format**
+6. **Update label to `soba:ready` after completion**
+
+## Important Notes
+
+- Think hard and choose the best architecture with good maintainability. (You don't need to respect existing implementations too much)
+- Maintaining compatibility is not required (Code complexity due to maintaining backward compatibility is more harmful)
+
+---
+
+## Execution Steps
+
+1. **Check Issue**
+   - Check content with `gh issue view <number>`
+   - Check comments with `gh issue view <number> --comments`
+
+2. **Investigate Codebase**
+   - Check related files and past implementations
+   - Identify impact scope and dependencies
+
+3. **Technology Selection**
+   - Decide on libraries and patterns to use
+   - Clarify selection reasons
+
+4. **Define Implementation Steps**
+   - Break down into testable units
+   - Document related files and side effects
+
+5. **Develop Test, Risk, and Schedule Plans**
+   - Test plan (unit and integration)
+   - Risks and countermeasures
+   - Implementation timeframe estimates
+
+6. **Create Plan File**
+   - Save to `./.tmp/plan-[slug].md`
+
+7. **Post Comment**
+   - `gh issue comment <number> --body-file ./.tmp/plan-[slug].md`
+
+8. **Update Label**
+   - `gh issue edit <number> --remove-label "soba:planning" --add-label "soba:ready"`
+
+---
+
+## Template
+
+```markdown
+# Implementation Plan: [Title]
+
+## Requirements Overview
+- [Purpose and background]
+- [Functional requirements]
+- [Acceptance criteria]
+
+## Design Policy
+- [Technology selection and reasons]
+- [Architectural considerations]
+
+## Implementation Steps
+1. [Step name]
+   - Work content: [Details]
+   - Related files: [File path]
+
+## Test Plan
+- Unit tests: [Target and cases]
+- Integration tests: [Scenarios]
+
+## Risks and Countermeasures
+- Risk: [Content]
+  Countermeasure: [Method]
+
+## Schedule
+- Estimate: Total [X] hours
+- By step: Each [Y] hours
+```

data/.claude/commands/soba/review.md

@@ -0,0 +1,91 @@
+---
+allowed-tools: Bash, Read, Write, Edit, MultiEdit, Grep, Glob, LS
+description: "Review a Pull Request for a soba Issue"
+---
+
+# Review PR
+
+Conduct PR review.
+
+## Context
+
+- Issue number: $ARGUMENTS
+
+## Workflow
+
+### 1. Check Issue
+
+```bash
+GH_PAGER= gh issue view <issue-number>
+GH_PAGER= gh issue view <issue-number> --comments
+```
+
+### 2. Check PR
+
+```bash
+GH_PAGER= gh pr view <PR-number>
+GH_PAGER= gh pr view <PR-number> --json mergeable,mergeStateStatus
+```
+
+### 3. Check Code Changes
+
+```bash
+GH_PAGER= gh pr diff <PR-number>
+```
+
+Review points:
+- Compliance with coding standards
+- Test implementation status
+- Security concerns
+- Presence of unnecessary diffs
+
+### 4. Check CI (Required - wait for completion)
+
+```bash
+gh pr checks <PR-number> --watch  # Timeout 600000
+```
+
+⚠️ **Important**: Do not post review results before CI completion
+
+### 5. Post Review Results
+
+Create `./.tmp/review-result-<issue-number>.md`:
+
+```markdown
+## Review Results
+
+- Issue: #<issue-number>
+- PR: #<PR-number>
+
+### ✅ Decision
+- [ ] Approve (LGTM)
+- [ ] Request changes
+
+### 🔄 Merge Status
+- [ ] No conflicts
+- [ ] Conflicts exist (rebase required)
+
+### 👍 Good Points
+- [Good aspects of implementation]
+
+### 🔧 Improvement Suggestions
+- [Specific improvement points]
+```
+
+Post:
+```bash
+gh pr comment <PR-number> --body "$(cat ./.tmp/review-result-<issue-number>.md)"
+```
+
+### 6. Update Labels
+
+For approval:
+```bash
+gh issue edit <issue-number> --remove-label "soba:reviewing" --add-label "soba:done"
+gh pr edit <PR-number> --add-label "soba:lgtm"
+```
+
+For change requests:
+```bash
+gh issue edit <issue-number> --remove-label "soba:reviewing" --add-label "soba:requires-changes"
+```

data/.claude/commands/soba/revise.md

@@ -0,0 +1,79 @@
+---
+allowed-tools: Bash, Read, Write, Edit, MultiEdit, Grep, Glob, LS
+description: "Revise implementation based on review feedback"
+---
+
+# Revise PR
+
+Address review feedback and comments.
+
+## Context
+
+- Issue number: $ARGUMENTS
+
+## Important Notes
+
+- Think hard and choose the best architecture with good maintainability. You don't need to respect existing implementations too much.
+- Maintaining compatibility is not required. Code complexity due to maintaining backward compatibility is more harmful.
+- Passing the full test suite is an **absolute requirement**. However, do not skip test code.
+
+## Workflow
+
+### 1. Check PR
+
+```bash
+GH_PAGER= gh pr list --search "linked:$ARGUMENTS" --state open --json number --jq '.[0].number'
+```
+
+### 2. Check Review Comments
+
+```bash
+GH_PAGER= gh pr view <PR-number> --comments
+```
+
+### 3. Address Review Comments
+
+Implement fixes based on review comments:
+- Improve code quality
+- Add/modify tests
+- Improve error handling
+- Remove unnecessary diffs
+
+### 4. Run Tests
+  - Run full test suite (required) # Timeout 600000
+
+### 5. Commit Changes
+
+```bash
+git add -A
+git commit -m "fix: Address review feedback
+
+- [Summary of changes]
+"
+git push
+```
+
+### 6. Post Completion Comment
+
+Create `./.tmp/revise-complete-<issue-number>.md`:
+
+```markdown
+## Review Feedback Addressed
+
+The following feedback has been addressed:
+- ✅ [Addressed item]
+
+All tests have been confirmed to pass.
+Please review again.
+```
+
+Post:
+```bash
+gh pr comment <PR-number> --body "$(cat ./.tmp/revise-complete-<issue-number>.md)"
+```
+
+### 7. Update Labels
+
+```bash
+gh issue edit <issue-number> --remove-label "soba:revising" --add-label "soba:review-requested"
+```

data/.devcontainer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sho DOUHASHI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/.devcontainer/README.md

@@ -0,0 +1,85 @@
+# Rails DevContainer
+
+A fully-featured development container configuration for Ruby on Rails projects with integrated tools and services.
+
+## Features
+
+- Pre-configured Ruby on Rails development environment
+- Docker Compose setup with Selenium for system testing
+- GitHub CLI, Node.js, Python, and AWS CLI pre-installed
+- Automatic Ruby version synchronization
+- MCP (Model Context Protocol) server integration
+- Volume mounts for SSH, AWS, GitHub, and Claude configurations
+
+## Requirements
+
+- Docker Desktop or Docker Engine
+- Visual Studio Code with Dev Containers extension
+- Git
+
+## Quick Start
+
+1. In your Rails project directory, add this repository as a git subtree:
+   ```bash
+   git subtree add --prefix=.devcontainer --squash git@github.com:douhashi/devcontainer-rails.git main
+   ```
+
+### Visual Studio Code
+
+2. Open your Rails project in VS Code:
+   ```bash
+   code .
+   ```
+
+3. When prompted, click "Reopen in Container" or run the command "Dev Containers: Reopen in Container"
+
+4. Wait for the container to build and post-create scripts to complete
+
+### DevContainer CLI
+
+2. Rebuild and start the development container:
+   ```bash
+   .devcontainer/bin/rebuild
+   .devcontainer/bin/up
+   ```
+
+3. The container will build and start with all configured services
+
+## Updating DevContainer
+
+To update the DevContainer configuration with the latest changes from the upstream repository:
+
+```bash
+git subtree pull --prefix=.devcontainer --squash git@github.com:douhashi/devcontainer-rails.git main
+```
+
+## Configuration
+
+### Ruby Version
+
+The Ruby version is automatically synchronized from `.tool-versions` file. To change it:
+1. Update `.tool-versions` in your Rails project
+2. Run `sync-ruby-version.sh` to update the DevContainer configuration
+3. Rebuild the container
+
+### Services
+
+- **App**: Main Rails application container (ports 5100, 3036)
+- **Selenium**: Chrome browser for system tests (port 4444)
+
+### Environment Variables
+
+- `KAMAL_REGISTRY_USERNAME`: Docker registry username for Kamal deployments
+- `KAMAL_REGISTRY_PASSWORD`: Docker registry password for Kamal deployments
+- `VITE_RUBY_HOST`: Vite development server host (default: 0.0.0.0)
+- `SELENIUM_URL`: Selenium server URL for system tests
+
+## Scripts
+
+- `post-create.sh`: Runs after container creation (installs packages, tools, Rails setup)
+- `post-attach.sh`: Runs each time you attach to the container
+- `sync-ruby-version.sh`: Updates DevContainer Ruby version from .tool-versions
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

data/.devcontainer/bin/devcontainer-common.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Function to start devcontainer
+up_devcontainer() {
+    local additional_flags="$1"
+    
+    # Get the tmux config path
+    tmux_config_path=~/.config/tmux
+    tmux_resolved_config_path=$(readlink -f "$tmux_config_path")
+    echo "Resolved config path: $tmux_resolved_config_path"
+    
+    # Construct the command to run the devcontainer
+    command="devcontainer up $additional_flags"
+    
+    # Add mount options
+    command+=" --mount type=bind,source=$tmux_resolved_config_path,target=/home/vscode/.config/tmux"
+    
+    # Add additional features
+    command+=" --additional-features='{ \
+            \"ghcr.io/duduribeiro/devcontainer-features/tmux:1\": {} \
+        }'"
+    
+    # Add workspace folder
+    command+=" --workspace-folder ."
+    
+    eval "$command"
+}
+
+# Function to connect to devcontainer
+exec_devcontainer() {
+    # Prepare exec command with environment variables
+    exec_command="devcontainer exec"
+    exec_command+=" --workspace-folder . /bin/bash"
+    
+    eval "$exec_command"
+}