consolle 0.2.6

data/lib/consolle/server/request_broker.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "thread"
+require "securerandom"
+require "logger"
+
+module Consolle
+  module Server
+    class RequestBroker
+      attr_reader :supervisor, :logger
+
+      def initialize(supervisor:, logger: nil)
+        @supervisor = supervisor
+        @logger = logger || Logger.new(STDOUT)
+        @queue = Queue.new
+        @running = false
+        @worker_thread = nil
+        @request_map = {}
+        @mutex = Mutex.new
+      end
+
+      def start
+        return if @running
+        
+        @running = true
+        @worker_thread = start_worker
+        logger.info "[RequestBroker] Started"
+      end
+
+      def stop
+        return unless @running
+        
+        @running = false
+        
+        # Push poison pill to wake up worker
+        @queue.push(nil)
+        
+        # Wait for worker to finish
+        @worker_thread&.join(5)
+        
+        logger.info "[RequestBroker] Stopped"
+      end
+
+      def process_request(request)
+        request_id = request["request_id"] || SecureRandom.uuid
+        
+        # Create future for response
+        future = RequestFuture.new
+        
+        # Store in map
+        @mutex.synchronize do
+          @request_map[request_id] = future
+        end
+        
+        # Queue request
+        @queue.push({
+          id: request_id,
+          request: request,
+          timestamp: Time.now
+        })
+        
+        # Wait for response (with timeout)
+        begin
+          future.get(timeout: request["timeout"] || 30)
+        rescue Timeout::Error
+          {
+            "success" => false,
+            "error" => "RequestTimeout",
+            "message" => "Request timed out",
+            "request_id" => request_id
+          }
+        ensure
+          # Clean up
+          @mutex.synchronize do
+            @request_map.delete(request_id)
+          end
+        end
+      end
+
+      private
+
+      def start_worker
+        Thread.new do
+          logger.info "[RequestBroker] Worker thread started"
+          
+          while @running
+            begin
+              # Get next request
+              item = @queue.pop
+              
+              # Check for poison pill
+              break if item.nil? && !@running
+              next if item.nil?
+              
+              # Process request
+              process_item(item)
+            rescue StandardError => e
+              logger.error "[RequestBroker] Worker error: #{e.message}"
+              logger.error e.backtrace.join("\n")
+            end
+          end
+          
+          logger.info "[RequestBroker] Worker thread stopped"
+        end
+      end
+
+      def process_item(item)
+        request_id = item[:id]
+        request = item[:request]
+        
+        logger.debug "[RequestBroker] Processing request: #{request_id}"
+        
+        # Get future
+        future = @mutex.synchronize { @request_map[request_id] }
+        return unless future
+        
+        # Process based on request type
+        response = case request["action"]
+        when "eval", "exec"
+          process_eval_request(request)
+        when "status"
+          process_status_request
+        when "restart"
+          process_restart_request
+        else
+          {
+            "success" => false,
+            "error" => "UnknownAction",
+            "message" => "Unknown action: #{request["action"]}"
+          }
+        end
+        
+        # Add request_id to response
+        response["request_id"] = request_id
+        
+        # Set future result
+        future.set(response)
+        
+        logger.debug "[RequestBroker] Request completed: #{request_id}"
+      rescue StandardError => e
+        logger.error "[RequestBroker] Error processing request #{request_id}: #{e.message}"
+        
+        error_response = {
+          "success" => false,
+          "error" => e.class.name,
+          "message" => e.message,
+          "request_id" => request_id
+        }
+        
+        future&.set(error_response)
+      end
+
+      def process_eval_request(request)
+        code = request["code"]
+        timeout = request["timeout"] || 30
+        
+        unless code
+          return {
+            "success" => false,
+            "error" => "MissingParameter",
+            "message" => "Missing required parameter: code"
+          }
+        end
+        
+        # Execute through supervisor
+        result = @supervisor.eval(code, timeout: timeout)
+        
+        # Format response
+        if result[:success]
+          {
+            "success" => true,
+            "result" => result[:output],
+            "execution_time" => result[:execution_time]
+          }
+        else
+          {
+            "success" => false,
+            "error" => "ExecutionError",
+            "message" => result[:output]
+          }
+        end
+      end
+
+      def process_status_request
+        {
+          "success" => true,
+          "running" => @supervisor.running?,
+          "pid" => @supervisor.pid,
+          "rails_root" => @supervisor.rails_root,
+          "rails_env" => @supervisor.rails_env
+        }
+      end
+
+      def process_restart_request
+        begin
+          # Restart the Rails console subprocess
+          new_pid = @supervisor.restart
+          
+          {
+            "success" => true,
+            "message" => "Rails console subprocess restarted",
+            "pid" => new_pid,
+            "rails_root" => @supervisor.rails_root,
+            "rails_env" => @supervisor.rails_env
+          }
+        rescue StandardError => e
+          logger.error "[RequestBroker] Restart failed: #{e.message}"
+          logger.error e.backtrace.join("\n")
+          
+          {
+            "success" => false,
+            "error" => "RestartFailed",
+            "message" => "Failed to restart Rails console: #{e.message}"
+          }
+        end
+      end
+
+      # Simple future implementation
+      class RequestFuture
+        def initialize
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @value = nil
+          @set = false
+        end
+
+        def set(value)
+          @mutex.synchronize do
+            @value = value
+            @set = true
+            @condition.signal
+          end
+        end
+
+        def get(timeout: nil)
+          @mutex.synchronize do
+            unless @set
+              @condition.wait(@mutex, timeout)
+              raise Timeout::Error, "Future timed out" unless @set
+            end
+            @value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/consolle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Consolle
+  VERSION = File.read(File.expand_path("../../../.version", __FILE__)).strip
+end

data/lib/consolle.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "consolle/version"
+require_relative "consolle/cli"
+
+# Server components
+require_relative "consolle/server/console_socket_server"
+require_relative "consolle/server/console_supervisor"
+require_relative "consolle/server/request_broker"
+
+module Consolle
+  class Error < StandardError; end
+end

data/mise/release.sh

@@ -0,0 +1,120 @@
+#!/bin/bash
+
+set -e
+
+# Set default version increment if not provided
+VERSION_INCREMENT="${1:-0.0.1}"
+
+# Validate version increment format
+if [[ ! "$VERSION_INCREMENT" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    echo "Error: Version increment must be in format X.Y.Z (e.g., 0.0.1)"
+    exit 1
+fi
+
+# Change to the project root directory
+cd "$(dirname "$0")/.."
+
+# Check if git repository is clean
+if [ -n "$(git status --porcelain)" ]; then
+    echo "Error: Git repository is not clean. Please commit or stash your changes."
+    git status --short
+    exit 1
+fi
+
+# Clean up old gem files
+echo "Cleaning up old gem files..."
+rm -f consolle-*.gem
+
+# Read current version from .version file
+if [ ! -f .version ]; then
+    echo "Error: .version file not found"
+    exit 1
+fi
+
+CURRENT_VERSION=$(cat .version)
+echo "Current version: $CURRENT_VERSION"
+
+# Parse version components
+IFS='.' read -ra CURRENT_PARTS <<< "$CURRENT_VERSION"
+IFS='.' read -ra INCREMENT_PARTS <<< "$VERSION_INCREMENT"
+
+# Validate current version format
+if [ ${#CURRENT_PARTS[@]} -ne 3 ]; then
+    echo "Error: Current version must be in format X.Y.Z"
+    exit 1
+fi
+
+# Calculate new version
+MAJOR=$((CURRENT_PARTS[0] + INCREMENT_PARTS[0]))
+MINOR=$((CURRENT_PARTS[1] + INCREMENT_PARTS[1]))
+PATCH=$((CURRENT_PARTS[2] + INCREMENT_PARTS[2]))
+
+# Handle carry-over
+if [ $PATCH -ge 10 ]; then
+    MINOR=$((MINOR + PATCH / 10))
+    PATCH=$((PATCH % 10))
+fi
+
+if [ $MINOR -ge 10 ]; then
+    MAJOR=$((MAJOR + MINOR / 10))
+    MINOR=$((MINOR % 10))
+fi
+
+NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+echo "New version: $NEW_VERSION"
+
+# Update .version file FIRST
+echo "$NEW_VERSION" > .version
+
+# Update Gemfile.lock with new version
+echo "Updating Gemfile.lock..."
+bundle install
+
+# Build the gem with new version
+echo "Building gem with new version..."
+if gem build consolle.gemspec; then
+    echo "Gem built successfully: consolle-$NEW_VERSION.gem"
+    
+    # Git operations
+    echo "Committing version bump..."
+    git add .version Gemfile.lock
+    git commit -m "Bump version to $NEW_VERSION"
+    
+    echo "Creating git tag..."
+    git tag -a "v$NEW_VERSION" -m "Release version $NEW_VERSION"
+    
+    echo "Pushing to remote..."
+    git push origin
+    git push origin "v$NEW_VERSION"
+    
+    # Ask about publishing to RubyGems.org
+    echo ""
+    read -p "Publish to RubyGems.org? (y/N): " publish_confirm
+    
+    if [[ "$publish_confirm" =~ ^[Yy]$ ]]; then
+        echo "Publishing to RubyGems.org..."
+        if gem push consolle-$NEW_VERSION.gem; then
+            echo "✓ Gem published successfully to RubyGems.org"
+            echo ""
+            echo "View your gem at: https://rubygems.org/gems/consolle"
+        else
+            echo "Error: RubyGems.org push failed"
+            echo "You can manually publish with:"
+            echo "  gem push consolle-$NEW_VERSION.gem"
+            exit 1
+        fi
+    else
+        echo "Skipping RubyGems.org publishing."
+        echo "You can manually publish later with:"
+        echo "  gem push consolle-$NEW_VERSION.gem"
+    fi
+    
+    echo "Release complete!"
+    echo "Version $NEW_VERSION has been released."
+else
+    echo "Error: Gem build failed with new version"
+    # Revert version change
+    echo "$CURRENT_VERSION" > .version
+    bundle install  # Revert Gemfile.lock
+    exit 1
+fi

data/rule.ko.md

@@ -0,0 +1,117 @@
+# Cone 명령어 가이드
+
+consolle는 Rails Console을 서버로 제공하는 래퍼인 `cone` 명령어를 제공합니다.
+
+`cone` 명령어를 사용하여 Rails console 세션을 시작하고 Rails에서 코드를 실행할 수 있습니다.
+
+Rails console과 마찬가지로 세션 내에서 실행한 결과는 유지되며, 명시적으로 종료해야만 사라집니다.
+
+사용 전에는 `status`로 상태를 확인하고, 작업 종료 후에는 `stop`해야 합니다.
+
+## Cone의 용도
+
+Cone은 디버깅, 데이터 탐색, 그리고 개발 보조 도구로 사용됩니다.
+
+개발 보조 도구로 사용할 때는 수정한 코드의 반영 여부를 항상 의식해야 합니다.
+
+코드를 수정한 경우 서버를 재시작하거나 `reload!`를 사용해야 최신 코드가 반영됩니다.
+
+기존 객체 역시 이전 코드를 참조하므로, 새롭게 만들어야 최신 코드를 사용합니다.
+
+## Cone 서버 시작과 중지
+
+`start` 명령어로 cone을 시작할 수 있으며, `-e`로 실행 환경을 지정할 수 있습니다.
+
+```bash
+$ cone start # 서버 시작
+$ cone start -e test # test 환경에서 console 시작
+```
+
+중지와 재시작 명령어도 제공합니다.
+
+Cone은 한 번에 하나의 세션만 제공하며, 실행 환경을 변경하려면 반드시 중지 후 재시작해야 합니다.
+
+```bash
+$ cone stop # 서버 중지
+```
+
+작업을 마치면 반드시 종료해 주세요.
+
+## Cone 서버 상태 확인
+
+```bash
+$ cone status
+✓ Rails console is running
+  PID: 36384
+  Environment: test
+  Session: /Users/ben/syncthing/workspace/karrot-inhouse/ehr/tmp/cone/cone.socket
+  Ready for input: Yes
+```
+
+## 코드 실행
+
+코드를 평가하고 출력한 결과가 반환됩니다. 평가 결과는 `=> ` 접두사와 함께 출력됩니다.
+
+```bash
+$ cone exec 'User.count'
+=> 1
+```
+
+변수를 사용하는 예제 (세션이 유지됩니다):
+
+```bash
+$ cone exec 'u = User.last'
+=> #<User id: 1, email: "user@example.com", created_at: "2025-07-17 15:16:34.685972000 +0900", updated_at: "2025-07-17 15:16:34.685972000 +0900">
+
+$ cone exec 'puts u'
+#<User:0x00000001104bbd18>
+=> nil
+```
+
+`-f` 옵션을 사용하여 Ruby 파일을 직접 실행할 수도 있습니다. Rails Runner와 달리 IRB 세션에서 실행됩니다.
+
+```bash
+$ cone exec -f example.rb
+```
+
+디버깅을 위한 `-v` 옵션(Verbose 출력)이 제공됩니다.
+
+```bash
+$ cone exec -v 'puts "hello, world"'
+```
+
+## 코드 입력 모범 사례
+
+### 홑따옴표 사용 (강력 권장)
+
+`cone exec`에 코드를 전달할 때는 **항상 홑따옴표를 사용하세요**. 이는 모든 cone 사용자에게 권장되는 방법입니다:
+
+```bash
+$ cone exec 'User.where(active: true).count'
+$ cone exec 'puts "Hello, world!"'
+```
+
+### --raw 옵션 사용
+
+**Claude Code 사용자 주의: --raw 옵션을 사용하지 마세요.** 이 옵션은 Claude Code 환경에서는 필요하지 않습니다.
+
+### 멀티라인 코드 지원
+
+Cone은 멀티라인 코드 실행을 완벽하게 지원합니다. 멀티라인 코드를 실행하는 방법은 여러 가지가 있습니다:
+
+#### 방법 1: 홑따옴표를 사용한 멀티라인 문자열
+```bash
+$ cone exec '
+users = User.active
+puts "Active users: #{users.count}"
+users.first
+'
+```
+
+#### 방법 2: 파일 사용
+복잡한 멀티라인 코드는 파일에 저장하세요:
+```bash
+$ cone exec -f complex_task.rb
+```
+
+모든 방법은 세션 상태를 유지하므로 변수와 객체가 실행 간에 지속됩니다.

data/rule.md

@@ -0,0 +1,117 @@
+# Cone Command Guide
+
+consolle provides the `cone` command, a wrapper that serves Rails Console as a server.
+
+Using the `cone` command, you can start a Rails console session and execute code in Rails.
+
+Similar to Rails console, results executed within the session are maintained and only disappear when explicitly terminated.
+
+Before use, check the status with `status`, and after finishing work, you should `stop` it.
+
+## Purpose of Cone
+
+Cone is used for debugging, data exploration, and as a development assistant tool.
+
+When using it as a development assistant tool, you must always be aware of whether modified code has been reflected.
+
+When code is modified, you need to restart the server or use `reload!` to reflect the latest code.
+
+Existing objects also reference old code, so you need to create new ones to use the latest code.
+
+## Starting and Stopping Cone Server
+
+You can start cone with the `start` command and specify the execution environment with `-e`.
+
+```bash
+$ cone start # Start server
+$ cone start -e test # Start console in test environment
+```
+
+It also provides stop and restart commands.
+
+Cone provides only one session at a time, and to change the execution environment, you must stop and restart.
+
+```bash
+$ cone stop # Stop server
+```
+
+Always terminate when you finish your work.
+
+## Checking Cone Server Status
+
+```bash
+$ cone status
+✓ Rails console is running
+  PID: 36384
+  Environment: test
+  Session: /Users/ben/syncthing/workspace/karrot-inhouse/ehr/tmp/cone/cone.socket
+  Ready for input: Yes
+```
+
+## Executing Code
+
+The evaluated and output results of code are returned. The evaluation result is output with the `=> ` prefix.
+
+```bash
+$ cone exec 'User.count'
+=> 1
+```
+
+Example using variables (session is maintained):
+
+```bash
+$ cone exec 'u = User.last'
+=> #<User id: 1, email: "user@example.com", created_at: "2025-07-17 15:16:34.685972000 +0900", updated_at: "2025-07-17 15:16:34.685972000 +0900">
+
+$ cone exec 'puts u'
+#<User:0x00000001104bbd18>
+=> nil
+```
+
+You can also execute Ruby files directly using the `-f` option. Unlike Rails Runner, this is executed in an IRB session.
+
+```bash
+$ cone exec -f example.rb
+```
+
+A `-v` option (Verbose output) is provided for debugging.
+
+```bash
+$ cone exec -v 'puts "hello, world"'
+```
+
+## Best Practices for Code Input
+
+### Using Single Quotes (Strongly Recommended)
+
+**Always use single quotes** when passing code to `cone exec`. This is the recommended practice for all cone users:
+
+```bash
+$ cone exec 'User.where(active: true).count'
+$ cone exec 'puts "Hello, world!"'
+```
+
+### Using the --raw Option
+
+**Note for Claude Code users: DO NOT use the --raw option.** This option is not needed in Claude Code environments.
+
+### Multi-line Code Support
+
+Cone fully supports multi-line code execution. There are several ways to execute multi-line code:
+
+#### Method 1: Multi-line String with Single Quotes
+```bash
+$ cone exec '
+users = User.active
+puts "Active users: #{users.count}"
+users.first
+'
+```
+
+#### Method 2: Using a File
+For complex multi-line code, save it in a file:
+```bash
+$ cone exec -f complex_task.rb
+```
+
+All methods maintain the session state, so variables and objects persist between executions.