tayo 0.1.11 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b925f8aa2d0555113bba7ca0f1ed1e2a4f7b923f4f8cd5f7ebc2ed0abb0a5df
-  data.tar.gz: 42fe13a69f4c8b9bca65b2d46f8bfe501e34f2c350658d75e277dc1fb2005268
+  metadata.gz: d61ea1f144cfaf69b20fa118160100a9398ebcc04240a39d445a2f7b7729e828
+  data.tar.gz: c08f57b24d2fbb5397fea80d0773335925706225aae2b5fb055060b8bfedbaa7
 SHA512:
-  metadata.gz: 13ce503cf8c8d0fd7c0ec6588cbf699d0713c01e6b1d9c26fa1b7c0339c4c1747b93b959e5e5071e9213ec28d6e2aa634032511f4ae921f5fbfeb2fd4ab5bac8
-  data.tar.gz: d131a5928299a44bf63b2a0e1c65ebcf12113643120fc5d2f5a2084643b7e05de9388e34575ffddc3ad1e1804268051ce4fdd8df5213609b5e0361a6f447b304
+  metadata.gz: b51cc3c508a857449b7ec7a88d6f0e9fb822ee3fdd0f42ce40b088a0eb0bec9eaa31c69789ca65cf22e1214d72fee707da9c2078dcfce9054b666ac787ec39d0
+  data.tar.gz: 413c144d1c28b9f6ca125bb0d43b5580ab2eb5aa421e89afd09afa289b66f06a1c2dfd173b0c942cb1a09dcc1a0e244869a5700ffd79c46243a416cf6b4e6557

data/CHANGELOG.md

@@ -0,0 +1,75 @@
+# 변경 기록 (Changelog)
+
+## [0.1.13] - 2025-06-30
+
+### 🚀 새로운 기능
+- **SQLite 프로덕션 최적화 명령 추가** (`tayo sqlite`):
+  - Rails 8 SQLite 프로덕션 환경 최적화 설정 자동 적용
+  - WAL 모드와 IMMEDIATE 트랜잭션으로 동시성 문제 해결
+  - busy_timeout 5초 설정으로 SQLITE_BUSY 에러 방지
+  - 캐시 및 메모리 최적화로 성능 향상
+  - 모든 데이터베이스(primary, cache, queue, cable)에 적용
+- **SQLite 설정 검증 도구**:
+  - `rails db:sqlite_check` - 모든 pragma 설정 검증
+  - `rails db:sqlite_stats` - 데이터베이스 성능 통계 확인
+- **SQLite 가이드 문서 자동 생성**: 상세한 프로덕션 가이드 포함
+
+### 🛠️ 개선사항
+- 공통 Base 클래스 추가로 코드 중복 제거
+- 테스트 커버리지 확대
+
+## [0.1.12] - 2025-01-20
+
+### 🚀 새로운 기능
+- **CLAUDE.md 문서 지원**: Claude AI 도우미를 위한 프로젝트별 지침 파일 지원
+- **Cloudflare DNS 설정 대폭 개선**:
+  - Cloudflare Zone 목록에서 도메인을 직접 선택하는 방식으로 변경
+  - 루트 도메인(@)과 서브도메인 선택 UI 개선
+  - 기존 DNS 레코드 확인 및 덮어쓰기 시 사용자 확인 프롬프트 추가
+  - Cloudflare API 토큰을 `~/.tayo` 파일에 안전하게 저장 및 재사용
+- **자동 Git 커밋**: `tayo gh`와 `tayo cf` 명령어 실행 후 자동으로 변경사항 커밋
+- **버전 표시**: 명령어 실행 시 Tayo 버전 표시
+
+### 🛠️ 개선사항
+- **Init 워크플로우 간소화**:
+  - Gemfile 수정 제거로 더 깔끔한 초기화 프로세스
+  - Docker 캐시 정리 기능 추가
+  - bootsnap 자동 처리 제거 (안정성 문제로 인해)
+- **GitHub Container Registry 설정**:
+  - 조직(Organization) 계정 지원 추가
+  - ghcr.io URL 중복 제거 버그 수정
+  - Docker 로그인 자동화
+
+### 🐛 버그 수정
+- Dockerfile bootsnap 프리컴파일 이슈 수정
+- DNS 레코드 생성 시 프록시 설정 누락 문제 해결
+
+## [0.1.11] - 2025-01-19
+
+### 🛠️ 개선사항
+- Bootsnap 처리를 DockerfileModifier 클래스로 리팩토링
+- 더 안정적인 bootsnap 라인 제거 로직 구현
+- 테스트 커버리지 강화
+
+## [0.1.10] - 2025-01-18
+
+### 🚀 새로운 기능
+- Dockerfile에서 bootsnap 관련 설정 자동 제거/비활성화
+
+### 🐛 버그 수정
+- Dockerfile bootsnap 프리컴파일 관련 다양한 엣지 케이스 처리
+
+## [0.1.9] - 2025-01-17
+
+### 🏗️ 기타 변경사항
+- 홈페이지 URL을 TeamMilestone 조직으로 업데이트
+- 저장소 이전에 따른 메타데이터 업데이트
+
+## [0.1.0] - 2025-01-15
+
+### 🎉 최초 릴리스
+- `tayo init`: Rails 프로젝트 초기 설정 (Docker, Welcome 페이지)
+- `tayo gh`: GitHub 저장소 및 Container Registry 설정
+- `tayo cf`: Cloudflare DNS 설정
+- OrbStack 자동 감지 및 실행
+- 한국어 UI 지원

data/CLAUDE.md

@@ -0,0 +1,58 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+Tayo is a Ruby gem that simplifies Rails app deployment to home servers using GitHub Container Registry and Cloudflare.
+
+## Common Development Commands
+
+### Testing
+```bash
+# Run all tests
+rake test
+
+# Run specific test file
+ruby -Ilib:test test/dockerfile_modifier_test.rb
+```
+
+### Building and Installing
+```bash
+# Build gem
+rake build
+
+# Install locally
+rake install
+
+# Release to RubyGems.org
+rake release
+```
+
+## Architecture
+
+### Core Structure
+- `lib/tayo/cli.rb` - Thor-based CLI entry point
+- `lib/tayo/commands/` - Command modules:
+  - `init.rb` - Rails project initialization with Docker setup
+  - `gh.rb` - GitHub repository and Container Registry configuration
+  - `cf.rb` - Cloudflare DNS configuration
+- `lib/tayo/dockerfile_modifier.rb` - Handles bootsnap removal from Dockerfiles
+
+### Key Patterns
+1. **Command Structure**: Each command is a separate module under `Commands`
+2. **Error Handling**: Use colorized Korean messages for user-friendly output
+3. **Security**: Store sensitive tokens with 600 permissions, use macOS Keychain for Cloudflare tokens
+4. **Git Integration**: Auto-commit after each major step with descriptive messages
+5. **User Interaction**: Use TTY::Prompt for interactive configuration
+
+### Workflow
+The typical usage flow:
+1. `tayo init` - Sets up Rails project with Docker
+2. `tayo gh` - Configures GitHub repository and Container Registry
+3. `tayo cf` - Sets up Cloudflare DNS
+4. `bin/kamal setup` - Deploys the application
+
+### Testing Approach
+- Uses Minitest framework
+- Tests focus on unit testing individual components
+- DockerfileModifier has comprehensive test coverage

data/README.md

@@ -1,6 +1,6 @@
 # Tayo
 
-Rails 애플리케이션을 홈서버에 배포하기 위한 도구입니다.
+Rails 애플리케이션을 홈서버에 배포하기 위한 도구입니다. GitHub Container Registry와 Cloudflare를 활용하여 간편한 배포 워크플로우를 제공합니다.
 
 ## 설치
 
@@ -23,15 +23,13 @@ tayo init
 이 명령어는 다음 작업들을 수행합니다:
 
 - **OrbStack 설치 확인**: Docker 컨테이너를 실행하기 위한 OrbStack이 설치되어 있는지 확인합니다
-- **Bundle 설치**: 의존성을 설치합니다
-- **Linux 플랫폼 추가**: `x86_64-linux`와 `aarch64-linux` 플랫폼을 Gemfile.lock에 추가합니다
 - **Dockerfile 생성**: Rails 7 기본 Dockerfile이 없으면 생성합니다
 - **Welcome 페이지 생성**: 
   - `app/controllers/welcome_controller.rb` 컨트롤러 생성
   - `app/views/welcome/index.html.erb` 뷰 파일 생성 (애니메이션이 있는 예쁜 랜딩 페이지)
   - `config/routes.rb`에 `root 'welcome#index'` 설정 추가
-- **Git 커밋**: 변경사항을 자동으로 커밋합니다
 - **Docker 캐시 정리**: 디스크 공간 확보를 위해 Docker 캐시를 정리합니다
+- **Git 커밋**: 변경사항을 자동으로 커밋합니다
 
 ### 2. `tayo gh` - GitHub 저장소 및 Container Registry 설정
 
@@ -52,6 +50,7 @@ tayo gh
 - **GitHub 원격 저장소 설정**:
   - 기존 원격 저장소가 있으면 사용
   - 없으면 새 저장소 생성 (public/private 선택 가능)
+  - 개인 계정 및 조직(Organization) 계정 모두 지원
   - 코드를 GitHub에 푸시
 - **GitHub Container Registry 설정**:
   - Registry URL 생성: `ghcr.io/username/repository-name`
@@ -62,6 +61,7 @@ tayo gh
 - **환경 변수 파일 준비**:
   - `.env.production` 파일 생성
   - `.gitignore`에 추가하여 보안 유지
+- **Git 커밋**: 설정 변경사항을 자동으로 커밋합니다
 
 ### 3. `tayo cf` - Cloudflare DNS 설정
 
@@ -73,27 +73,86 @@ tayo cf
 
 이 명령어는 다음 작업들을 수행합니다:
 
-- **설정 파일 확인**: `config/deploy.yml` 파일에서 서버 IP와 도메인 정보를 읽습니다
 - **Cloudflare 인증**:
   - API 토큰 입력 요청 (처음 실행 시)
-  - 토큰을 안전하게 저장 (macOS Keychain 사용)
-- **도메인 Zone 확인**: 
-  - Cloudflare 계정에서 도메인을 찾습니다
-  - Zone ID를 자동으로 가져옵니다
+  - 토큰을 `~/.tayo` 파일에 안전하게 저장하여 재사용
+  - 필요한 권한: Zone:Read, DNS:Edit
+- **도메인 설정**: 
+  - Cloudflare 계정의 Zone 목록에서 도메인 선택
+  - 루트 도메인(@) 또는 서브도메인 설정 지원
+  - 대화형 UI로 쉽게 설정 가능
 - **DNS 레코드 생성/업데이트**:
-  - A 레코드 생성: 도메인을 서버 IP에 연결
-  - 기존 레코드가 있으면 업데이트
+  - A 레코드 생성: IP 주소로 연결
+  - CNAME 레코드 생성: 도메인으로 연결
+  - 기존 레코드가 있으면 사용자 확인 후 업데이트
   - Proxied 설정 (Cloudflare CDN 사용)
-- **설정 완료 확인**:
-  - DNS 설정이 완료되면 성공 메시지 표시
-  - 도메인으로 접속 가능함을 안내
+- **배포 설정 업데이트**:
+  - `config/deploy.yml` 파일의 proxy.host 자동 업데이트
+  - 서버 정보 및 SSH 사용자 설정
+- **Git 커밋**: DNS 설정 변경사항을 자동으로 커밋합니다
+
+### 4. `tayo sqlite` - SQLite 프로덕션 최적화 설정
+
+Rails 8의 SQLite를 프로덕션 환경에서 안정적으로 사용하기 위한 최적화 설정을 적용합니다.
+
+```bash
+tayo sqlite
+```
+
+이 명령어는 다음 작업들을 수행합니다:
+
+- **database.yml 업데이트**:
+  - WAL (Write-Ahead Logging) 모드 활성화
+  - IMMEDIATE 트랜잭션 모드 설정
+  - busy_timeout 5초 설정으로 "database is locked" 에러 방지
+  - 캐시 및 메모리 최적화 설정
+  - 모든 데이터베이스(primary, cache, queue, cable)에 적용
+- **SQLite pragma 초기화 파일 생성**:
+  - `config/initializers/sqlite3_pragmas.rb` 생성
+  - 런타임 시 추가 최적화 및 설정 검증
+  - 주기적인 PRAGMA optimize 실행
+- **설정 검증 도구 생성**:
+  - `rails db:sqlite_check` - SQLite 설정 검증
+  - `rails db:sqlite_stats` - SQLite 성능 통계 확인
+- **가이드 문서 생성**:
+  - `sqlite_guide.md` - 상세한 SQLite 프로덕션 가이드
+- **Git 커밋**: 모든 변경사항을 자동으로 커밋합니다
+
+## 전체 워크플로우
+
+```bash
+# 1. 새 Rails 프로젝트 생성
+rails new myapp
+cd myapp
+
+# 2. Tayo로 배포 준비
+tayo init    # Rails 프로젝트 초기화
+tayo gh      # GitHub 저장소 및 Container Registry 설정
+tayo cf      # Cloudflare DNS 설정
+tayo sqlite  # SQLite 프로덕션 최적화 (선택사항)
+
+# 3. Kamal로 배포
+bin/kamal setup
+```
+
+## 주요 기능
+
+- **🚀 원스톱 배포 설정**: 3개의 명령어로 배포 준비 완료
+- **🐳 Docker 기반**: OrbStack과 GitHub Container Registry 활용
+- **🌐 Cloudflare 통합**: 자동 DNS 설정 및 CDN 지원
+- **🗄️ SQLite 최적화**: Rails 8 SQLite 프로덕션 환경 완벽 지원
+- **🔒 보안**: 토큰과 환경 변수를 안전하게 관리
+- **🎯 한국어 UI**: 모든 메시지가 한국어로 제공
+- **🛡️ 오류 처리**: 각 단계별 검증과 친절한 오류 메시지
+
+## 요구사항
 
-각 명령어는 단계별로 진행 상황을 표시하며, 오류가 발생하면 친절한 안내 메시지를 제공합니다.
+- Ruby 3.1.0 이상
+- Rails 7.0 이상
+- macOS (OrbStack 사용)
+- GitHub 계정
+- Cloudflare 계정
 
-rails new 로 프로젝트 생성 후 
-bundle exec tayo init
-bundle exec tayo gh
-bundle exec tayo cf
+## 라이선스
 
-순으로 진행 후
-bin/kamal setup 으로 배포 진행
+MIT License

data/lib/tayo/cli.rb

@@ -5,6 +5,7 @@ require "colorize"
 require_relative "commands/init"
 require_relative "commands/gh"
 require_relative "commands/cf"
+require_relative "commands/sqlite"
 
 module Tayo
   class CLI < Thor
@@ -23,6 +24,11 @@ module Tayo
       Commands::Cf.new.execute
     end
 
+    desc "sqlite", "SQLite 프로덕션 최적화 설정을 적용합니다"
+    def sqlite
+      Commands::Sqlite.new.execute
+    end
+
     desc "version", "Tayo 버전을 표시합니다"
     def version
       puts "Tayo #{VERSION}"

data/lib/tayo/commands/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tayo
+  module Commands
+    class Base
+      private
+
+      def in_rails_project?
+        File.exist?('Gemfile') && File.exist?('config/application.rb')
+      end
+    end
+  end
+end

data/lib/tayo/commands/cf.rb

@@ -17,30 +17,27 @@ module Tayo
           return
         end
 
-        # 1. 도메인 입력받기
-        domain_info = get_domain_input
+        # --- 로직 순서 변경 ---
         
-        # 2. Cloudflare 토큰 생성 페이지 열기 및 권한 안내
-        open_token_creation_page
-        
-        # 3. 토큰 입력받기
+        # 2. 토큰 입력받기
         token = get_cloudflare_token
         
-        # 4. Cloudflare API로 도메인 목록 조회 및 선택
-        selected_zone = select_cloudflare_zone(token)
-        
-        # 5. 루트 도메인 레코드 확인
+        # 3. Cloudflare 존 선택 및 도메인 구성 (새로운 방식)
+        domain_info = configure_domain_from_zones(token)
+        selected_zone = domain_info[:selected_zone_object]
+
+        # 4. 기존 DNS 레코드 확인 (참고용)
         existing_records = check_existing_records(token, selected_zone, domain_info)
         
-        # 6. DNS 레코드 추가/수정
+        # 5. DNS 레코드 추가/수정 (루트 도메인 덮어쓰기 로직 포함)
         setup_dns_record(token, selected_zone, domain_info, existing_records)
         
-        # 7. config/deploy.yml 업데이트
+        # 6. config/deploy.yml 업데이트
         update_deploy_config(domain_info)
 
         puts "\n🎉 Cloudflare DNS 설정이 완료되었습니다!".colorize(:green)
         
-        # 변경사항 커밋
+        # 7. 변경사항 커밋
         commit_cloudflare_changes(domain_info)
       end
 
@@ -50,31 +47,59 @@ module Tayo
         File.exist?("Gemfile") && File.exist?("config/application.rb")
       end
 
-      def get_domain_input
-        prompt = TTY::Prompt.new
+      # [신규] Cloudflare Zone 목록에서 도메인을 선택하고 구성하는 메소드
+      def configure_domain_from_zones(token)
+        puts "\n🌐 Cloudflare 계정의 도메인 목록을 조회합니다...".colorize(:yellow)
         
-        puts "\n📝 배포할 도메인을 설정합니다.".colorize(:yellow)
+        zones = get_cloudflare_zones(token)
         
-        domain = prompt.ask("배포할 도메인을 입력하세요 (예: myapp.com, api.example.com):") do |q|
-          q.validate(/\A[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\z/, "올바른 도메인 형식을 입력해주세요 (예: myapp.com)")
+        if zones.empty?
+          puts "❌ Cloudflare에 등록된 도메인(Zone)이 없습니다.".colorize(:red)
+          puts "먼저 https://dash.cloudflare.com 에서 도메인을 추가해주세요.".colorize(:cyan)
+          exit 1
         end
         
-        # 도메인이 루트인지 서브도메인인지 판단
-        parts = domain.split('.')
-        if parts.length == 2
-          { type: :root, domain: domain, zone: domain }
-        else
-          zone = parts[-2..-1].join('.')
-          { type: :subdomain, domain: domain, zone: zone, subdomain: parts[0..-3].join('.') }
+        prompt = TTY::Prompt.new
+        # 사용자가 Zone을 이름으로 선택하고, 선택 시 전체 Zone 객체를 반환하도록 설정
+        zone_choices = zones.map { |zone| { name: "#{zone['name']} (#{zone['status']})", value: zone } }
+        
+        selected_zone = prompt.select("설정할 도메인(Zone)을 선택하세요:", zone_choices, filter: true, per_page: 10)
+        zone_name = selected_zone['name']
+        puts "✅ 선택된 Zone: #{zone_name}".colorize(:green)
+
+        domain_type = prompt.select("\n어떤 종류의 도메인을 설정하시겠습니까?", [
+          { name: "루트 도메인 (@) - 예: #{zone_name}", value: :root },
+          { name: "서브도메인 - 예: www.#{zone_name}", value: :subdomain }
+        ])
+
+        if domain_type == :root
+          return {
+            type: :root,
+            domain: zone_name,
+            zone: zone_name,
+            selected_zone_object: selected_zone
+          }
+        else # :subdomain
+          subdomain_part = prompt.ask("사용할 서브도메인을 입력하세요 (예: www, api):") do |q|
+            q.required true
+            q.validate(/^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/, "유효한 서브도메인을 입력해주세요 (특수문자, . 사용 불가)")
+          end
+
+          full_domain = "#{subdomain_part.downcase}.#{zone_name}"
+          puts "✅ 설정할 전체 도메인: #{full_domain}".colorize(:green)
+
+          return {
+            type: :subdomain,
+            domain: full_domain,
+            zone: zone_name,
+            subdomain: subdomain_part.downcase,
+            selected_zone_object: selected_zone
+          }
         end
       end
 
       def open_token_creation_page
         puts "\n🔑 Cloudflare API 토큰이 필요합니다.".colorize(:yellow)
-        puts "토큰 생성 페이지를 엽니다...".colorize(:cyan)
-        
-        # Cloudflare API 토큰 생성 페이지 열기
-        system("open 'https://dash.cloudflare.com/profile/api-tokens'")
         
         puts "\n다음 권한으로 토큰을 생성해주세요:".colorize(:yellow)
         puts ""
@@ -88,9 +113,28 @@ module Tayo
         puts "• Zone → DNS → Edit".colorize(:white)
         puts "  (Zone Resources: Select 'All zones')".colorize(:gray)
         puts ""
+
+        puts "토큰 생성 페이지를 엽니다...".colorize(:cyan)
+        
+        system("open 'https://dash.cloudflare.com/profile/api-tokens'")        
       end
 
       def get_cloudflare_token
+        existing_token = load_saved_token
+        
+        if existing_token
+          puts "💾 저장된 토큰을 발견했습니다.".colorize(:cyan)
+          if test_cloudflare_token(existing_token)
+            puts "✅ 저장된 토큰이 유효합니다.".colorize(:green)
+            return existing_token
+          else
+            puts "❌ 저장된 토큰이 만료되거나 무효합니다. 새 토큰을 입력해주세요.".colorize(:yellow)
+            open_token_creation_page
+          end
+        else
+          open_token_creation_page
+        end
+        
         prompt = TTY::Prompt.new
         
         token = prompt.mask("생성된 Cloudflare API 토큰을 붙여넣으세요:")
@@ -100,9 +144,9 @@ module Tayo
           exit 1
         end
         
-        # 토큰 유효성 간단 확인
         if test_cloudflare_token(token.strip)
           puts "✅ 토큰이 확인되었습니다.".colorize(:green)
+          save_token(token.strip)
           return token.strip
         else
           puts "❌ 토큰이 올바르지 않거나 권한이 부족합니다.".colorize(:red)
@@ -125,27 +169,42 @@ module Tayo
         return false
       end
 
-      def select_cloudflare_zone(token)
-        puts "\n🌐 Cloudflare 도메인 목록을 조회합니다...".colorize(:yellow)
-        
-        zones = get_cloudflare_zones(token)
-        
-        if zones.empty?
-          puts "❌ Cloudflare에 등록된 도메인이 없습니다.".colorize(:red)
-          puts "먼저 https://dash.cloudflare.com 에서 도메인을 추가해주세요.".colorize(:cyan)
-          exit 1
+      def load_saved_token
+        token_file = File.expand_path("~/.tayo")
+        return nil unless File.exist?(token_file)
+        
+        begin
+          content = File.read(token_file)
+          token_line = content.lines.find { |line| line.start_with?("CLOUDFLARE_TOKEN=") }
+          return nil unless token_line
+          
+          token = token_line.split("=", 2)[1]&.strip
+          return token unless token.nil? || token.empty?
+          
+          nil
+        rescue => e
+          puts "⚠️  토큰 파일 읽기 중 오류가 발생했습니다: #{e.message}".colorize(:yellow)
+          nil
+        end
+      end
+
+      def save_token(token)
+        token_file = File.expand_path("~/.tayo")
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        
+        content = <<~CONTENT
+          # Tayo Configuration File
+          # Created: #{timestamp}
+          CLOUDFLARE_TOKEN=#{token}
+        CONTENT
+        
+        begin
+          File.write(token_file, content)
+          File.chmod(0600, token_file)
+          puts "💾 토큰이 ~/.tayo 파일에 저장되었습니다.".colorize(:green)
+        rescue => e
+          puts "⚠️  토큰 저장 중 오류가 발생했습니다: #{e.message}".colorize(:yellow)
         end
-        
-        prompt = TTY::Prompt.new
-        zone_choices = zones.map { |zone| "#{zone['name']} (#{zone['status']})" }
-        
-        selected = prompt.select("도메인을 선택하세요:", zone_choices)
-        zone_name = selected.split(' ').first
-        
-        selected_zone = zones.find { |zone| zone['name'] == zone_name }
-        puts "✅ 선택된 도메인: #{zone_name}".colorize(:green)
-        
-        return selected_zone
       end
 
       def get_cloudflare_zones(token)
@@ -174,13 +233,10 @@ module Tayo
       def check_existing_records(token, zone, domain_info)
         puts "\n🔍 기존 DNS 레코드를 확인합니다...".colorize(:yellow)
         
-        zone_id = zone['id']
-        zone_name = zone['name']
-        
-        # 루트 도메인의 A/CNAME 레코드 확인
-        records = get_dns_records(token, zone_id, zone_name, ['A', 'CNAME'])
+        target_name = (domain_info[:type] == :root) ? zone['name'] : domain_info[:domain]
+        records = get_dns_records(token, zone['id'], target_name, ['A', 'CNAME'])
         
-        puts "기존 레코드: #{records.length}개 발견".colorize(:gray)
+        puts "   (확인 대상: #{target_name}, 발견된 A/CNAME 레코드: #{records.length}개)".colorize(:gray)
         
         return records
       end
@@ -190,10 +246,7 @@ module Tayo
         
         types.each do |type|
           uri = URI("https://api.cloudflare.com/client/v4/zones/#{zone_id}/dns_records")
-          uri.query = URI.encode_www_form({
-            type: type,
-            name: name
-          })
+          uri.query = URI.encode_www_form({ type: type, name: name })
           
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true
@@ -215,71 +268,74 @@ module Tayo
         puts "❌ DNS 레코드 조회 중 오류: #{e.message}".colorize(:red)
         return []
       end
-
+      
       def setup_dns_record(token, zone, domain_info, existing_records)
         puts "\n⚙️  DNS 레코드를 설정합니다...".colorize(:yellow)
         
-        # 홈서버 IP/URL 입력받기
         prompt = TTY::Prompt.new
         
-        server_info = prompt.ask("홈서버 IP 또는 도메인을 입력하세요:") do |q|
+        server_info = prompt.ask("연결할 서버 IP 또는 도메인을 입력하세요:") do |q|
           q.validate(/\A.+\z/, "서버 정보를 입력해주세요")
         end
         
-        # SSH 사용자 계정 입력받기
         ssh_user = prompt.ask("SSH 사용자 계정을 입력하세요:", default: "root")
         
-        # IP인지 도메인인지 판단
         is_ip = server_info.match?(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/)
         record_type = is_ip ? 'A' : 'CNAME'
         
         zone_id = zone['id']
         zone_name = zone['name']
         
-        # 도메인 정보에 따라 레코드 설정
         final_domain = determine_final_domain(domain_info, zone_name, existing_records)
-        
-        # 대상 도메인의 모든 A/CNAME 레코드 확인
         all_records = get_dns_records(token, zone_id, final_domain[:name], ['A', 'CNAME'])
         
-        if all_records.any?
-          existing_record = all_records.first
-          
-          # 동일한 타입이고 같은 값이면 건너뛰기
-          if existing_record['type'] == record_type && existing_record['content'] == server_info
-            puts "✅ DNS 레코드가 이미 올바르게 설정되어 있습니다.".colorize(:green)
-            puts "   #{final_domain[:full_domain]} → #{server_info} (#{record_type} 레코드)".colorize(:gray)
-          else
-            # 타입이 다르거나 값이 다른 경우 삭제 후 재생성
-            puts "⚠️  기존 레코드를 삭제하고 새로 생성합니다.".colorize(:yellow)
-            puts "   기존: #{existing_record['content']} (#{existing_record['type']}) → 새로운: #{server_info} (#{record_type})".colorize(:gray)
-            
-            # 기존 레코드 삭제
-            delete_dns_record(token, zone_id, existing_record['id'])
+        is_already_configured = all_records.length == 1 &&
+                               all_records.first['type'] == record_type &&
+                               all_records.first['content'] == server_info
+
+        if is_already_configured
+          puts "✅ DNS 레코드가 이미 올바르게 설정되어 있습니다.".colorize(:green)
+          puts "   #{final_domain[:full_domain]} → #{server_info} (#{record_type} 레코드)".colorize(:gray)
+        else
+          # [수정됨] 기존 레코드가 있으면 사용자에게 확인을 받습니다.
+          if all_records.any?
+            puts "\n⚠️  '#{final_domain[:full_domain]}'에 이미 설정된 DNS 레코드가 있습니다.".colorize(:yellow)
+            puts "--------------------------------------------------"
+            all_records.each do |record|
+              puts "  - 타입: ".ljust(10) + "#{record['type']}".colorize(:cyan)
+              puts "    내용: ".ljust(10) + "#{record['content']}".colorize(:cyan)
+              puts "    프록시: ".ljust(10) + "#{record['proxied'] ? '활성' : '비활성'}".colorize(:cyan)
+              puts " "
+            end
+            puts "--------------------------------------------------"
+
+            message = "이 레코드를 삭제하고 새로 설정하시겠습니까? (이 작업은 되돌릴 수 없습니다)"
+            unless prompt.yes?(message)
+              puts "❌ DNS 설정이 사용자에 의해 취소되었습니다. 스크립트를 종료합니다.".colorize(:red)
+              exit 0
+            end
             
-            # 새 레코드 생성
+            puts "\n✅ 사용자가 승인하여 기존 레코드를 삭제하고 새 레코드를 생성합니다.".colorize(:green)
+            all_records.each do |record|
+              delete_dns_record(token, zone_id, record['id'])
+            end
+            create_dns_record(token, zone_id, final_domain[:name], record_type, server_info)
+
+          else
+            # 기존 레코드가 없으면 바로 생성합니다.
             create_dns_record(token, zone_id, final_domain[:name], record_type, server_info)
           end
-        else
-          # DNS 레코드 생성
-          create_dns_record(token, zone_id, final_domain[:name], record_type, server_info)
         end
         
-        # 최종 도메인 정보 저장
         @final_domain = final_domain[:full_domain]
         @server_info = server_info
         @ssh_user = ssh_user
       end
-
+      
       def determine_final_domain(domain_info, zone_name, existing_records)
         case domain_info[:type]
         when :root
-          if existing_records.any?
-            puts "⚠️  루트 도메인에 이미 레코드가 있습니다. app.#{zone_name}을 사용합니다.".colorize(:yellow)
-            { name: "app.#{zone_name}", full_domain: "app.#{zone_name}" }
-          else
-            { name: zone_name, full_domain: zone_name }
-          end
+          { name: zone_name, full_domain: zone_name }
         when :subdomain
           { name: domain_info[:domain], full_domain: domain_info[:domain] }
         end
@@ -298,7 +354,8 @@ module Tayo
           type: type,
           name: name,
           content: content,
-          ttl: 300
+          ttl: 300,
+          proxied: true
         }
         
         request.body = data.to_json
@@ -306,7 +363,7 @@ module Tayo
         
         if response.code == '200'
           puts "✅ DNS 레코드가 생성되었습니다.".colorize(:green)
-          puts "   #{name} → #{content} (#{type} 레코드)".colorize(:gray)
+          puts "   #{name} → #{content} (#{type} 레코드, 프록시됨)".colorize(:gray)
         else
           puts "❌ DNS 레코드 생성에 실패했습니다: #{response.code}".colorize(:red)
           puts response.body
@@ -328,16 +385,12 @@ module Tayo
         
         response = http.request(request)
         
-        if response.code == '200'
-          puts "✅ 기존 DNS 레코드가 삭제되었습니다.".colorize(:green)
-        else
+        unless response.code == '200'
           puts "❌ DNS 레코드 삭제에 실패했습니다: #{response.code}".colorize(:red)
           puts response.body
-          exit 1
         end
       rescue => e
         puts "❌ DNS 레코드 삭제 중 오류: #{e.message}".colorize(:red)
-        exit 1
       end
 
       def update_deploy_config(domain_info)
@@ -356,27 +409,23 @@ module Tayo
         if content.include?("proxy:")
           content.gsub!(/(\s+host:\s+).*$/, "\\1#{@final_domain}")
         else
-          # proxy 섹션이 없으면 추가
           proxy_config = "\n# Proxy configuration\nproxy:\n  ssl: true\n  host: #{@final_domain}\n"
           content += proxy_config
         end
         
         # servers 설정 업데이트
         if content.match?(/servers:\s*\n\s*web:\s*\n\s*-\s*/)
-          content.gsub!(/(\s*servers:\s*\n\s*web:\s*\n\s*-\s*)[\d.]+/, "\\1#{@server_info}")
+          content.gsub!(/(\s*servers:\s*\n\s*web:\s*\n\s*-\s*)[\w.-]+/, "\\1#{@server_info}")
         end
         
         # ssh user 설정 업데이트
         if @ssh_user && @ssh_user != "root"
           if content.match?(/^ssh:/)
-            # 기존 ssh 섹션 업데이트
             content.gsub!(/^ssh:\s*\n\s*user:\s*\w+/, "ssh:\n  user: #{@ssh_user}")
           else
-            # ssh 섹션 추가 (accessories 섹션 앞에 추가)
             if content.match?(/^# Use accessory services/)
               content.gsub!(/^# Use accessory services/, "# Use a different ssh user than root\nssh:\n  user: #{@ssh_user}\n\n# Use accessory services")
             else
-              # 파일 끝에 추가
               content += "\n# Use a different ssh user than root\nssh:\n  user: #{@ssh_user}\n"
             end
           end
@@ -386,31 +435,28 @@ module Tayo
         puts "✅ config/deploy.yml이 업데이트되었습니다.".colorize(:green)
         puts "   proxy.host: #{@final_domain}".colorize(:gray)
         puts "   servers.web: #{@server_info}".colorize(:gray)
-        puts "   ssh.user: #{@ssh_user}".colorize(:gray) if @ssh_user && @ssh_user != "root"
+        if @ssh_user && @ssh_user != "root"
+          puts "   ssh.user: #{@ssh_user}".colorize(:gray)
+        end
       end
       
       def commit_cloudflare_changes(domain_info)
         puts "\n📝 변경사항을 Git에 커밋합니다...".colorize(:yellow)
         
-        # 변경된 파일이 있는지 확인
-        status_output = `git status --porcelain`.strip
+        status_output = `git status --porcelain config/deploy.yml`.strip
         
         if status_output.empty?
-          puts "ℹ️  커밋할 변경사항이 없습니다.".colorize(:yellow)
+          puts "ℹ️  커밋할 변경사항이 없습니다.".colorize(:cyan)
           return
         end
         
-        # Git add
-        system("git add -A")
+        system("git add config/deploy.yml")
         
-        # Commit 메시지 생성
-        commit_message = "Configure Cloudflare DNS settings\n\n- Setup DNS for domain: #{domain_info[:domain]}\n- Configure server IP: #{domain_info[:server_ip]}\n- Update deployment configuration\n- Add proxy host settings\n\n🤖 Generated with Tayo"
+        commit_message = "feat: Configure Cloudflare DNS for #{@final_domain}\n\n- Set DNS record for #{@final_domain} to point to #{@server_info}\n- Update deployment configuration in config/deploy.yml\n\n🤖 Generated by Tayo"
         
-        # Commit 실행
         if system("git commit -m \"#{commit_message}\"")
           puts "✅ 변경사항이 성공적으로 커밋되었습니다.".colorize(:green)
           
-          # GitHub에 푸시
           if system("git push", out: File::NULL, err: File::NULL)
             puts "✅ 변경사항이 GitHub에 푸시되었습니다.".colorize(:green)
           else

data/lib/tayo/commands/init.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "colorize"
-require_relative "../dockerfile_modifier"
+# require_relative "../dockerfile_modifier"
 
 module Tayo
   module Commands
@@ -17,8 +17,7 @@ module Tayo
         check_orbstack
         create_welcome_page        
         clear_docker_cache
-        ensure_dockerfile_exists
-        disable_bootsnap_in_dockerfile
+        ensure_dockerfile_exists        
         commit_changes
         puts "✅ Tayo가 성공적으로 설정되었습니다!".colorize(:green)
       end
@@ -83,16 +82,6 @@ module Tayo
           puts "✅ Dockerfile이 이미 존재합니다.".colorize(:green)
         end        
       end
-      
-      def disable_bootsnap_in_dockerfile
-        puts "🔧 Dockerfile에서 bootsnap을 비활성화합니다...".colorize(:yellow)
-        begin
-          modifier = DockerfileModifier.new
-          modifier.init
-        rescue => e
-          puts "⚠️  Dockerfile 수정 중 오류가 발생했습니다: #{e.message}".colorize(:yellow)
-        end
-      end
 
       def create_welcome_page
         # Welcome 컨트롤러가 이미 있는지 확인

data/lib/tayo/commands/sqlite.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require 'tayo/commands/base'
+require 'git'
+require 'colorize'
+require 'tty-prompt'
+
+module Tayo
+  module Commands
+    class Sqlite < Base
+      def execute
+        puts "\n🗄️  SQLite 프로덕션 최적화 설정을 시작합니다...".colorize(:yellow)
+        puts "Tayo #{Tayo::VERSION}".colorize(:light_black)
+        
+        unless in_rails_project?
+          puts "❌ Rails 프로젝트가 아닙니다. Rails 프로젝트 루트에서 실행해주세요.".colorize(:red)
+          exit 1
+        end
+        
+        puts "\n이 명령은 다음 작업을 수행합니다:".colorize(:light_black)
+        puts "  • database.yml에 SQLite 프로덕션 최적화 설정 추가"
+        puts "  • SQLite pragma 초기화 파일 생성"
+        puts "  • SQLite 설정 검증 rake task 생성"
+        puts "  • SQLite 프로덕션 가이드 문서 생성"
+        
+        prompt = TTY::Prompt.new
+        continue = prompt.yes?("\n계속하시겠습니까?")
+        
+        unless continue
+          puts "취소되었습니다.".colorize(:yellow)
+          exit 0
+        end
+        
+        # Git 상태 체크
+        git = Git.open('.')
+        unless git.status.changed.empty? && git.status.added.empty? && git.status.deleted.empty?
+          puts "\n⚠️  커밋되지 않은 변경사항이 있습니다.".colorize(:yellow)
+          puts "SQLite 설정을 적용하기 전에 현재 상태를 커밋하는 것을 권장합니다.".colorize(:light_black)
+          
+          commit_now = prompt.yes?("\n지금 커밋하시겠습니까?")
+          if commit_now
+            git.add(all: true)
+            git.commit("현재 상태 저장 (tayo sqlite 실행 전)")
+            puts "✓ 현재 상태를 커밋했습니다.".colorize(:green)
+          end
+        end
+        
+        # database.yml 업데이트
+        update_database_yml
+        
+        # SQLite pragma 초기화 파일 생성
+        create_sqlite_pragma_initializer
+        
+        # SQLite 검증 rake task 생성
+        create_sqlite_check_rake_task
+        
+        # SQLite 가이드 문서 생성
+        create_sqlite_guide
+        
+        # Git 커밋
+        begin
+          git.add('config/database.yml')
+          git.add('config/initializers/sqlite3_pragmas.rb')
+          git.add('lib/tasks/sqlite_check.rake')
+          git.add('sqlite_guide.md')
+          
+          commit_message = <<~MSG
+            SQLite 프로덕션 최적화 설정 추가
+            
+            - WAL 모드와 IMMEDIATE 트랜잭션으로 동시성 문제 해결
+            - busy_timeout 5초 설정으로 SQLITE_BUSY 에러 방지
+            - 캐시 및 메모리 최적화로 성능 향상
+            - 설정 검증을 위한 rake task 추가
+            - 상세 가이드 문서 포함
+          MSG
+          
+          git.commit(commit_message)
+          puts "\n✓ 변경사항을 Git에 커밋했습니다.".colorize(:green)
+        rescue => e
+          puts "\n⚠️  Git 커밋 실패: #{e.message}".colorize(:yellow)
+          puts "수동으로 커밋해주세요.".colorize(:light_black)
+        end
+        
+        puts "\n✅ SQLite 프로덕션 최적화 설정이 완료되었습니다!".colorize(:green)
+        puts "\n다음 명령으로 설정을 검증할 수 있습니다:".colorize(:light_black)
+        puts "  rails db:sqlite_check".colorize(:cyan)
+        puts "  rails db:sqlite_stats".colorize(:cyan)
+        puts "\n자세한 내용은 sqlite_guide.md 파일을 참고하세요.".colorize(:light_black)
+      end
+      
+      private
+      
+      def update_database_yml
+        puts "\n📝 database.yml 업데이트 중...".colorize(:blue)
+        
+        database_yml_path = 'config/database.yml'
+        unless File.exist?(database_yml_path)
+          puts "❌ config/database.yml 파일을 찾을 수 없습니다.".colorize(:red)
+          exit 1
+        end
+        
+        # 백업 생성
+        backup_path = "#{database_yml_path}.backup"
+        FileUtils.cp(database_yml_path, backup_path)
+        puts "  백업 생성: #{backup_path}".colorize(:light_black)
+        
+        content = File.read(database_yml_path)
+        
+        # SQLite 최적화 설정 추가
+        optimized_content = add_sqlite_optimizations(content)
+        
+        File.write(database_yml_path, optimized_content)
+        puts "✓ database.yml이 업데이트되었습니다.".colorize(:green)
+      end
+      
+      def add_sqlite_optimizations(content)
+        # 이미 최적화 설정이 있는지 확인
+        if content.include?('transaction_mode: IMMEDIATE')
+          puts "  이미 SQLite 최적화 설정이 적용되어 있습니다.".colorize(:yellow)
+          return content
+        end
+        
+        # production 섹션 찾기
+        if content =~ /^production:\s*$/
+          # 기존 production 설정이 단순한 경우
+          if content =~ /^production:\s*\n\s+<<:\s*\*default/
+            # 새로운 production 설정으로 교체
+            new_production = <<~YAML
+            production:
+              primary:
+                <<: *default
+                database: storage/production.sqlite3
+                transaction_mode: IMMEDIATE
+                pragmas:
+                  journal_mode: WAL
+                  synchronous: NORMAL
+                  cache_size: 2000
+                  journal_size_limit: 27103364
+                  foreign_keys: ON
+                  mmap_size: 134217728
+                  busy_timeout: 5000
+              cache:
+                <<: *default
+                database: storage/production_cache.sqlite3
+                migrations_paths: db/cache_migrate
+                transaction_mode: IMMEDIATE
+                pragmas:
+                  journal_mode: WAL
+                  synchronous: NORMAL
+                  cache_size: 2000
+                  journal_size_limit: 27103364
+                  foreign_keys: ON
+                  mmap_size: 134217728
+                  busy_timeout: 5000
+              queue:
+                <<: *default
+                database: storage/production_queue.sqlite3
+                migrations_paths: db/queue_migrate
+                transaction_mode: IMMEDIATE
+                pragmas:
+                  journal_mode: WAL
+                  synchronous: NORMAL
+                  cache_size: 2000
+                  journal_size_limit: 27103364
+                  foreign_keys: ON
+                  mmap_size: 134217728
+                  busy_timeout: 5000
+              cable:
+                <<: *default
+                database: storage/production_cable.sqlite3
+                migrations_paths: db/cable_migrate
+                transaction_mode: IMMEDIATE
+                pragmas:
+                  journal_mode: WAL
+                  synchronous: NORMAL
+                  cache_size: 2000
+                  journal_size_limit: 27103364
+                  foreign_keys: ON
+                  mmap_size: 134217728
+                  busy_timeout: 5000
+            YAML
+            
+            content.sub!(/^production:\s*\n\s+<<:\s*\*default\s*\n\s+database:\s+storage\/production\.sqlite3/, new_production.chomp)
+          end
+        end
+        
+        # default 섹션에 busy_timeout 추가
+        unless content.include?('pragmas:')
+          content.sub!(/^(\s+timeout:\s+5000)/, "\\1\n  pragmas:\n    busy_timeout: 5000")
+        end
+        
+        content
+      end
+      
+      def create_sqlite_pragma_initializer
+        puts "\n📝 SQLite pragma 초기화 파일 생성 중...".colorize(:blue)
+        
+        initializer_path = 'config/initializers/sqlite3_pragmas.rb'
+        
+        # consulteam의 sqlite3_pragmas.rb 내용
+        initializer_content = <<~RUBY
+        # SQLite3 프로덕션 최적화 설정
+        # database.yml의 pragma 설정을 보완하는 추가 설정
+        
+        # ActiveRecord가 연결을 설정할 때마다 실행되도록 설정
+        ActiveSupport.on_load(:active_record) do
+          if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+            # SQLite3Adapter의 configure_connection 메서드 오버라이드
+            module SQLite3BusyTimeoutPatch
+              def configure_connection
+                super
+                # busy_timeout을 확실하게 설정 (밀리초 단위)
+                if @raw_connection.respond_to?(:busy_timeout)
+                  @raw_connection.busy_timeout(5000)
+                end
+                raw_execute("PRAGMA busy_timeout = 5000", "SCHEMA")
+                raw_execute("PRAGMA journal_size_limit = 27103364", "SCHEMA")
+              end
+            end
+            
+            ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(SQLite3BusyTimeoutPatch)
+          end
+        end
+        
+        Rails.application.config.after_initialize do
+          ActiveRecord::Base.connection_pool.with_connection do |connection|
+            if connection.adapter_name == 'SQLite'
+              # 개발 환경에서도 중요한 설정은 적용
+              # SQLite3 gem의 busy_timeout 메서드를 직접 호출
+              if connection.raw_connection.respond_to?(:busy_timeout)
+                connection.raw_connection.busy_timeout(5000)
+              else
+                connection.execute("PRAGMA busy_timeout = 5000")
+              end
+              connection.execute("PRAGMA journal_size_limit = 27103364")
+              
+              if Rails.env.production?
+                # WAL 모드 확인 (database.yml에서 이미 설정되어 있어야 함)
+                result = connection.execute("PRAGMA journal_mode")
+                journal_mode = result.first["journal_mode"] rescue result.first.values.first
+                
+                unless journal_mode.upcase == "WAL"
+                  Rails.logger.warn "WARNING: SQLite is not in WAL mode. Production performance may be severely impacted."
+                end
+                
+                # busy_timeout 확인
+                result = connection.execute("PRAGMA busy_timeout")
+                busy_timeout = result.first["busy_timeout"] rescue result.first.values.first
+                
+                if busy_timeout.to_i < 5000
+                  Rails.logger.warn "WARNING: SQLite busy_timeout is less than 5000ms. This may cause SQLITE_BUSY errors under load."
+                end
+                
+                # 추가 최적화 설정
+                connection.execute("PRAGMA temp_store = MEMORY")
+                connection.execute("PRAGMA optimize")
+                
+                Rails.logger.info "SQLite production optimizations applied successfully"
+                Rails.logger.info "Journal mode: \#{journal_mode}, Busy timeout: \#{busy_timeout}ms"
+              end
+            end
+          end
+        end
+        
+        # 주기적인 최적화 실행 (선택사항)
+        if Rails.env.production? && defined?(ActiveRecord::Base)
+          Thread.new do
+            loop do
+              sleep(4.hours)
+              begin
+                ActiveRecord::Base.connection_pool.with_connection do |connection|
+                  if connection.adapter_name == 'SQLite'
+                    connection.execute("PRAGMA optimize")
+                    Rails.logger.info "SQLite PRAGMA optimize executed"
+                  end
+                end
+              rescue => e
+                Rails.logger.error "Failed to run SQLite optimization: \#{e.message}"
+              end
+            end
+          end
+        end
+        RUBY
+        
+        File.write(initializer_path, initializer_content)
+        puts "✓ #{initializer_path} 파일이 생성되었습니다.".colorize(:green)
+      end
+      
+      def create_sqlite_check_rake_task
+        puts "\n📝 SQLite 검증 rake task 생성 중...".colorize(:blue)
+        
+        # lib/tasks 디렉토리 생성
+        FileUtils.mkdir_p('lib/tasks')
+        
+        rake_task_path = 'lib/tasks/sqlite_check.rake'
+        
+        # consulteam의 sqlite_check.rake 내용
+        rake_task_content = <<~RUBY
+        namespace :db do
+          desc "SQLite 프로덕션 설정 검증"
+          task sqlite_check: :environment do
+            if ActiveRecord::Base.connection.adapter_name == 'SQLite'
+              puts "\\n=== SQLite 프로덕션 설정 검증 ==="
+              
+              connection = ActiveRecord::Base.connection
+              
+              # 각 pragma 설정 확인
+              pragmas = {
+                'journal_mode' => 'WAL',
+                'synchronous' => 'NORMAL',
+                'cache_size' => '2000',
+                'journal_size_limit' => '27103364',
+                'foreign_keys' => '1',
+                'mmap_size' => '134217728',
+                'busy_timeout' => '5000'
+              }
+              
+              all_good = true
+              
+              pragmas.each do |pragma, expected|
+                result = connection.execute("PRAGMA \#{pragma}")
+                actual = result.first[pragma] rescue result.first.values.first
+                
+                if pragma == 'foreign_keys'
+                  status = actual.to_s == expected ? "✓" : "✗"
+                elsif pragma == 'journal_mode'
+                  status = actual.to_s.upcase == expected ? "✓" : "✗"
+                elsif pragma == 'synchronous'
+                  # NORMAL = 1 in SQLite
+                  status = (actual.to_s == '1' || actual.to_s.upcase == expected) ? "✓" : "✗"
+                else
+                  status = actual.to_s == expected ? "✓" : "✗"
+                end
+                
+                puts "\#{status} \#{pragma.ljust(20)}: \#{actual} \#{status == '✗' ? "(예상값: \#{expected})" : ""}"
+                all_good = false if status == "✗"
+              end
+              
+              # transaction_mode 확인 (Rails 로그에서만 확인 가능)
+              puts "\\n참고: transaction_mode=IMMEDIATE 설정은 런타임에서만 확인 가능합니다."
+              
+              if all_good
+                puts "\\n✅ 모든 SQLite 프로덕션 설정이 올바르게 구성되었습니다!"
+              else
+                puts "\\n⚠️  일부 설정이 권장값과 다릅니다. database.yml을 확인하세요."
+              end
+            else
+              puts "이 태스크는 SQLite 데이터베이스에서만 사용 가능합니다."
+            end
+          end
+          
+          desc "SQLite 성능 통계 확인"
+          task sqlite_stats: :environment do
+            if ActiveRecord::Base.connection.adapter_name == 'SQLite'
+              puts "\\n=== SQLite 성능 통계 ==="
+              
+              connection = ActiveRecord::Base.connection
+              
+              # 데이터베이스 파일 크기
+              db_path = connection.instance_variable_get(:@config)[:database]
+              if File.exist?(db_path)
+                size_mb = File.size(db_path) / 1024.0 / 1024.0
+                puts "데이터베이스 크기: \#{'%.2f' % size_mb} MB"
+                
+                # WAL 파일 크기 확인
+                wal_path = "\#{db_path}-wal"
+                if File.exist?(wal_path)
+                  wal_size_mb = File.size(wal_path) / 1024.0 / 1024.0
+                  puts "WAL 파일 크기: \#{'%.2f' % wal_size_mb} MB"
+                end
+              end
+              
+              # 페이지 정보
+              result = connection.execute("PRAGMA page_count")
+              page_count = result.first.values.first
+              
+              result = connection.execute("PRAGMA page_size")
+              page_size = result.first.values.first
+              
+              puts "페이지 수: \#{page_count}"
+              puts "페이지 크기: \#{page_size} bytes"
+              
+              # 캐시 히트율 (대략적인 추정)
+              result = connection.execute("PRAGMA cache_size")
+              cache_size = result.first.values.first
+              puts "캐시 크기: \#{cache_size} pages"
+              
+              puts "\\n실시간 성능 모니터링을 위해서는 애플리케이션 로그를 확인하세요."
+            else
+              puts "이 태스크는 SQLite 데이터베이스에서만 사용 가능합니다."
+            end
+          end
+        end
+        RUBY
+        
+        File.write(rake_task_path, rake_task_content)
+        puts "✓ #{rake_task_path} 파일이 생성되었습니다.".colorize(:green)
+      end
+      
+      def create_sqlite_guide
+        puts "\n📝 SQLite 가이드 문서 생성 중...".colorize(:blue)
+        
+        guide_path = 'sqlite_guide.md'
+        
+        # consulteam의 sqlite_guide.md 내용
+        guide_content = File.read('/Users/alfonso/projects/consulteam/sqlite_guide.md')
+        
+        File.write(guide_path, guide_content)
+        puts "✓ #{guide_path} 파일이 생성되었습니다.".colorize(:green)
+      end
+    end
+  end
+end

data/lib/tayo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tayo
-  VERSION = "0.1.11"
+  VERSION = "0.1.13"
 end

data/scripts/setup_rubygems_key.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+# RubyGems API 키 설정 스크립트
+
+echo "🔑 RubyGems API 키 설정 도우미"
+echo "================================"
+echo ""
+echo "이 스크립트는 RubyGems API 키를 안전하게 저장합니다."
+echo ""
+
+# 옵션 선택
+echo "저장 방법을 선택하세요:"
+echo "1) ~/.gem/credentials (표준 방법)"
+echo "2) macOS Keychain (가장 안전)"
+echo "3) 둘 다"
+echo ""
+read -p "선택 (1-3): " choice
+
+# API 키 입력
+echo ""
+read -s -p "RubyGems API 키를 입력하세요: " api_key
+echo ""
+
+case $choice in
+  1)
+    # credentials 파일에 저장
+    mkdir -p ~/.gem
+    echo "---" > ~/.gem/credentials
+    echo ":rubygems_api_key: $api_key" >> ~/.gem/credentials
+    chmod 0600 ~/.gem/credentials
+    echo "✅ ~/.gem/credentials에 저장되었습니다."
+    ;;
+  2)
+    # Keychain에 저장
+    security add-generic-password -a "$USER" -s "rubygems-api-key" -w "$api_key" -U
+    echo "✅ macOS Keychain에 저장되었습니다."
+    ;;
+  3)
+    # 둘 다
+    mkdir -p ~/.gem
+    echo "---" > ~/.gem/credentials
+    echo ":rubygems_api_key: $api_key" >> ~/.gem/credentials
+    chmod 0600 ~/.gem/credentials
+    security add-generic-password -a "$USER" -s "rubygems-api-key" -w "$api_key" -U
+    echo "✅ 두 곳 모두에 저장되었습니다."
+    ;;
+  *)
+    echo "❌ 잘못된 선택입니다."
+    exit 1
+    ;;
+esac
+
+echo ""
+echo "🎉 설정이 완료되었습니다!"
+echo ""
+echo "이제 다음 명령으로 gem을 배포할 수 있습니다:"
+echo "  rake release"
+echo ""
+echo "또는 Keychain에서 키를 사용하려면:"
+echo "  GEM_HOST_API_KEY=\$(security find-generic-password -a \"$USER\" -s \"rubygems-api-key\" -w) rake release"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tayo
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.13
 platform: ruby
 authors:
 - 이원섭wonsup Lee/Alfonso
@@ -75,18 +75,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".DS_Store"
+- CHANGELOG.md
+- CLAUDE.md
 - README.md
 - Rakefile
 - exe/tayo
 - lib/tayo.rb
 - lib/tayo/cli.rb
+- lib/tayo/commands/base.rb
 - lib/tayo/commands/cf.rb
 - lib/tayo/commands/gh.rb
 - lib/tayo/commands/init.rb
+- lib/tayo/commands/sqlite.rb
 - lib/tayo/dockerfile_modifier.rb
 - lib/tayo/version.rb
 - pkg/homebody-0.1.0.gem
 - repomix-output.xml
+- scripts/setup_rubygems_key.sh
 - sig/tayo.rbs
 homepage: https://github.com/TeamMilestone/tayo
 licenses: []