consolle 0.3.9 → 0.4.1

data/lib/consolle/history.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module Consolle
+  # Manages command history for sessions
+  class History
+    attr_reader :registry
+
+    def initialize(project_path = Dir.pwd)
+      @registry = SessionRegistry.new(project_path)
+    end
+
+    # Log a command execution to session history
+    def log_command(session_id:, target:, code:, result:)
+      log_path = registry.history_log_path(session_id)
+
+      entry = {
+        'timestamp' => Time.now.iso8601,
+        'session_id' => session_id,
+        'target' => target,
+        'request_id' => result['request_id'],
+        'code' => code,
+        'success' => result['success'],
+        'result' => result['result'],
+        'error' => result['error'],
+        'message' => result['message'],
+        'execution_time' => result['execution_time']
+      }
+
+      FileUtils.mkdir_p(File.dirname(log_path))
+      File.open(log_path, 'a') do |f|
+        f.puts JSON.generate(entry)
+      end
+
+      # Update command count in registry
+      registry.record_command(session_id)
+
+      entry
+    rescue StandardError
+      nil
+    end
+
+    # Query history for a session
+    def query(session_id: nil, target: nil, limit: nil, today: false, date: nil,
+              success_only: false, failed_only: false, grep: nil, all_sessions: false)
+      entries = []
+
+      # Get sessions to query
+      sessions = if session_id
+                   [registry.find_session(session_id: session_id)]
+                 elsif target
+                   if all_sessions
+                     # All sessions with this target (including stopped)
+                     registry.list_sessions(include_stopped: true).select { |s| s['target'] == target }
+                   else
+                     # Most recent session with this target
+                     [registry.find_session(target: target)]
+                   end
+                 else
+                   # Current project sessions
+                   if all_sessions
+                     registry.list_sessions(include_stopped: true)
+                   else
+                     registry.list_sessions(include_stopped: false)
+                   end
+                 end
+
+      sessions.compact.each do |session|
+        session_entries = load_history(session['id'])
+        session_entries.each { |e| e['_session'] = session }
+        entries.concat(session_entries)
+      end
+
+      # Apply filters
+      entries = filter_by_date(entries, today: today, date: date)
+      entries = filter_by_status(entries, success_only: success_only, failed_only: failed_only)
+      entries = filter_by_grep(entries, grep) if grep
+
+      # Sort by timestamp descending
+      entries = entries.sort_by { |e| e['timestamp'] }.reverse
+
+      # Apply limit
+      entries = entries.first(limit) if limit
+
+      entries
+    end
+
+    # Format history entry for display (compact)
+    def format_entry(entry, show_session: true)
+      timestamp = Time.parse(entry['timestamp']).strftime('%Y-%m-%d %H:%M:%S')
+      session_prefix = show_session ? "[#{entry['_session']&.dig('short_id') || entry['session_id']&.[](0, 4)}] " : ''
+      code_preview = entry['code'].to_s.gsub("\n", ' ').strip
+      code_preview = "#{code_preview[0, 60]}..." if code_preview.length > 63
+
+      lines = []
+      lines << "#{session_prefix}#{timestamp} | #{code_preview}"
+
+      if entry['success']
+        result_preview = entry['result'].to_s.gsub("\n", ' ').strip
+        result_preview = "#{result_preview[0, 70]}..." if result_preview.length > 73
+        exec_time = entry['execution_time'] ? " (#{entry['execution_time'].round(3)}s)" : ''
+        lines << "#{result_preview}#{exec_time}"
+      else
+        error_msg = entry['error'] || entry['message'] || 'Error'
+        lines << "ERROR: #{error_msg}"
+      end
+
+      lines.join("\n")
+    end
+
+    # Format history entry for verbose display
+    def format_entry_verbose(entry)
+      lines = []
+      lines << '━' * 60
+      timestamp = Time.parse(entry['timestamp']).strftime('%Y-%m-%d %H:%M:%S')
+      session_info = entry['_session']
+      session_str = session_info ? "#{session_info['short_id']} (#{session_info['target']})" : entry['session_id']
+
+      lines << "[#{timestamp}] Session: #{session_str}"
+      lines << '━' * 60
+      lines << 'Code:'
+      entry['code'].to_s.lines.each { |line| lines << "  #{line.chomp}" }
+      lines << ''
+
+      if entry['success']
+        lines << 'Result:'
+        entry['result'].to_s.lines.each { |line| lines << "  #{line.chomp}" }
+      else
+        lines << "Error: #{entry['error']}"
+        lines << entry['message'] if entry['message']
+      end
+
+      lines << ''
+      lines << "Execution time: #{entry['execution_time']&.round(3)}s" if entry['execution_time']
+      lines << '━' * 60
+
+      lines.join("\n")
+    end
+
+    # Format history as JSON
+    def format_json(entries)
+      JSON.pretty_generate(entries.map { |e| e.except('_session') })
+    end
+
+    # Get total command count for a session
+    def command_count(session_id)
+      load_history(session_id).size
+    end
+
+    private
+
+    def load_history(session_id)
+      log_path = registry.history_log_path(session_id)
+      return [] unless File.exist?(log_path)
+
+      entries = []
+      File.readlines(log_path).each do |line|
+        entry = JSON.parse(line.strip)
+        entries << entry
+      rescue JSON::ParserError
+        next
+      end
+
+      entries
+    end
+
+    def filter_by_date(entries, today: false, date: nil)
+      return entries unless today || date
+
+      target_date = if today
+                      Date.today
+                    elsif date.is_a?(String)
+                      Date.parse(date)
+                    else
+                      date
+                    end
+
+      entries.select do |e|
+        entry_date = Time.parse(e['timestamp']).to_date
+        entry_date == target_date
+      end
+    end
+
+    def filter_by_status(entries, success_only: false, failed_only: false)
+      return entries unless success_only || failed_only
+
+      if success_only
+        entries.select { |e| e['success'] }
+      elsif failed_only
+        entries.reject { |e| e['success'] }
+      else
+        entries
+      end
+    end
+
+    def filter_by_grep(entries, pattern)
+      regex = Regexp.new(pattern, Regexp::IGNORECASE)
+      entries.select do |e|
+        e['code']&.match?(regex) || e['result']&.match?(regex)
+      end
+    rescue RegexpError
+      # If invalid regex, treat as literal string
+      entries.select do |e|
+        e['code']&.include?(pattern) || e['result']&.include?(pattern)
+      end
+    end
+  end
+end

data/lib/consolle/session_registry.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'securerandom'
+
+module Consolle
+  # Manages session registry with unique session IDs
+  # Provides persistent storage for session metadata even after sessions stop
+  class SessionRegistry
+    SCHEMA_VERSION = 2
+    SESSION_ID_LENGTH = 8
+    SHORT_ID_LENGTH = 4
+
+    attr_reader :project_path
+
+    def initialize(project_path = Dir.pwd)
+      @project_path = project_path
+    end
+
+    # Generate a new unique session ID (8 hex characters)
+    def generate_session_id
+      SecureRandom.hex(SESSION_ID_LENGTH / 2)
+    end
+
+    # Get short ID (first 4 characters)
+    def short_id(session_id)
+      session_id[0, SHORT_ID_LENGTH]
+    end
+
+    # Create a new session entry
+    def create_session(target:, socket_path:, pid:, rails_env:, mode:)
+      session_id = generate_session_id
+
+      session_data = {
+        'id' => session_id,
+        'short_id' => short_id(session_id),
+        'target' => target,
+        'project' => project_path,
+        'project_hash' => project_hash,
+        'rails_env' => rails_env,
+        'mode' => mode,
+        'status' => 'running',
+        'pid' => pid,
+        'socket_path' => socket_path,
+        'created_at' => Time.now.iso8601,
+        'started_at' => Time.now.iso8601,
+        'stopped_at' => nil,
+        'last_activity_at' => Time.now.iso8601,
+        'command_count' => 0
+      }
+
+      with_registry_lock do
+        registry = load_registry
+        registry['sessions'][session_id] = session_data
+        save_registry(registry)
+      end
+
+      # Create session directory
+      ensure_session_directory(session_id)
+
+      # Save session metadata
+      save_session_metadata(session_id, session_data)
+
+      session_data
+    end
+
+    # Update session status to stopped
+    def stop_session(session_id: nil, target: nil, reason: 'user_requested')
+      session = find_session(session_id: session_id, target: target)
+      return nil unless session
+
+      with_registry_lock do
+        registry = load_registry
+        if registry['sessions'][session['id']]
+          registry['sessions'][session['id']]['status'] = 'stopped'
+          registry['sessions'][session['id']]['stopped_at'] = Time.now.iso8601
+          registry['sessions'][session['id']]['stop_reason'] = reason
+          save_registry(registry)
+        end
+      end
+
+      # Update metadata file
+      metadata = load_session_metadata(session['id'])
+      if metadata
+        metadata['status'] = 'stopped'
+        metadata['stopped_at'] = Time.now.iso8601
+        metadata['stop_reason'] = reason
+        save_session_metadata(session['id'], metadata)
+      end
+
+      session
+    end
+
+    # Record command execution
+    def record_command(session_id)
+      with_registry_lock do
+        registry = load_registry
+        if registry['sessions'][session_id]
+          registry['sessions'][session_id]['command_count'] ||= 0
+          registry['sessions'][session_id]['command_count'] += 1
+          registry['sessions'][session_id]['last_activity_at'] = Time.now.iso8601
+          save_registry(registry)
+        end
+      end
+    end
+
+    # Find session by ID (full or short) or target name
+    def find_session(session_id: nil, target: nil, status: nil)
+      registry = load_registry
+
+      if session_id
+        # Try exact match first
+        session = registry['sessions'][session_id]
+        return session if session && (status.nil? || session['status'] == status)
+
+        # Try short ID match
+        matches = registry['sessions'].values.select do |s|
+          s['short_id'] == session_id && s['project'] == project_path
+        end
+        matches = matches.select { |s| s['status'] == status } if status
+        return matches.first if matches.size == 1
+
+        # Ambiguous short ID
+        return nil if matches.size > 1
+      end
+
+      if target
+        # Find by target name in current project
+        matches = registry['sessions'].values.select do |s|
+          s['target'] == target && s['project'] == project_path
+        end
+        matches = matches.select { |s| s['status'] == status } if status
+
+        # Return most recent running session, or most recently created
+        matches.sort_by { |s| s['created_at'] }.last
+      end
+    end
+
+    # Find running session by target
+    def find_running_session(target:)
+      find_session(target: target, status: 'running')
+    end
+
+    # List sessions for current project
+    def list_sessions(include_stopped: false, all_projects: false)
+      registry = load_registry
+
+      sessions = registry['sessions'].values
+
+      # Filter by project unless all_projects
+      sessions = sessions.select { |s| s['project'] == project_path } unless all_projects
+
+      # Filter by status
+      sessions = sessions.select { |s| s['status'] == 'running' } unless include_stopped
+
+      # Sort by created_at descending
+      sessions.sort_by { |s| s['created_at'] }.reverse
+    end
+
+    # List only stopped sessions
+    def list_stopped_sessions(all_projects: false)
+      registry = load_registry
+
+      sessions = registry['sessions'].values.select { |s| s['status'] == 'stopped' }
+
+      # Filter by project unless all_projects
+      sessions = sessions.select { |s| s['project'] == project_path } unless all_projects
+
+      # Sort by stopped_at descending
+      sessions.sort_by { |s| s['stopped_at'] || s['created_at'] }.reverse
+    end
+
+    # Remove session and its history
+    def remove_session(session_id: nil, target: nil)
+      session = find_session(session_id: session_id, target: target)
+      return nil unless session
+
+      # Check if running
+      if session['status'] == 'running'
+        return { error: 'running', session: session }
+      end
+
+      with_registry_lock do
+        registry = load_registry
+        registry['sessions'].delete(session['id'])
+        save_registry(registry)
+      end
+
+      # Remove session directory
+      session_dir = session_directory(session['id'])
+      FileUtils.rm_rf(session_dir) if Dir.exist?(session_dir)
+
+      session
+    end
+
+    # Remove all stopped sessions (prune)
+    def prune_sessions(all_projects: false)
+      stopped = list_stopped_sessions(all_projects: all_projects)
+      removed = []
+
+      stopped.each do |session|
+        result = remove_session(session_id: session['id'])
+        # Check if result is session data (success) vs error hash
+        removed << result if result && !result.key?(:error)
+      end
+
+      removed
+    end
+
+    # Get session directory path
+    def session_directory(session_id)
+      File.join(sessions_base_dir, session_id)
+    end
+
+    # Get history log path for session
+    def history_log_path(session_id)
+      File.join(session_directory(session_id), 'history.log')
+    end
+
+    # Migration from old sessions.json format
+    def migrate_from_legacy
+      legacy_sessions_file = File.join(project_path, 'tmp', 'cone', 'sessions.json')
+      return unless File.exist?(legacy_sessions_file)
+
+      legacy_data = JSON.parse(File.read(legacy_sessions_file))
+      return if legacy_data.empty?
+
+      legacy_data.each do |target, info|
+        next if target == '_schema'
+
+        # Create new session entry for running legacy sessions
+        if info['process_pid'] && process_alive?(info['process_pid'])
+          create_session(
+            target: target,
+            socket_path: info['socket_path'],
+            pid: info['process_pid'],
+            rails_env: 'development',
+            mode: 'pty'
+          )
+        end
+      end
+    end
+
+    private
+
+    def registry_path
+      File.expand_path('~/.cone/registry.json')
+    end
+
+    def sessions_base_dir
+      File.join(File.expand_path('~/.cone/sessions'), project_hash)
+    end
+
+    def project_hash
+      project_path.gsub('/', '-')
+    end
+
+    def ensure_session_directory(session_id)
+      dir = session_directory(session_id)
+      FileUtils.mkdir_p(dir)
+      dir
+    end
+
+    def load_registry
+      FileUtils.mkdir_p(File.dirname(registry_path))
+
+      if File.exist?(registry_path)
+        data = JSON.parse(File.read(registry_path))
+        # Ensure schema version
+        data['_schema'] ||= SCHEMA_VERSION
+        data['sessions'] ||= {}
+        data
+      else
+        { '_schema' => SCHEMA_VERSION, 'sessions' => {} }
+      end
+    rescue JSON::ParserError
+      { '_schema' => SCHEMA_VERSION, 'sessions' => {} }
+    end
+
+    def save_registry(registry)
+      registry['_schema'] = SCHEMA_VERSION
+      temp_path = "#{registry_path}.tmp.#{Process.pid}"
+      File.write(temp_path, JSON.pretty_generate(registry))
+      File.rename(temp_path, registry_path)
+    rescue StandardError => e
+      File.unlink(temp_path) if File.exist?(temp_path)
+      raise e
+    end
+
+    def with_registry_lock
+      FileUtils.mkdir_p(File.dirname(registry_path))
+      lock_file_path = "#{registry_path}.lock"
+
+      File.open(lock_file_path, File::RDWR | File::CREAT, 0o644) do |f|
+        f.flock(File::LOCK_EX)
+        yield
+      ensure
+        f.flock(File::LOCK_UN)
+      end
+    end
+
+    def load_session_metadata(session_id)
+      metadata_path = File.join(session_directory(session_id), 'metadata.json')
+      return nil unless File.exist?(metadata_path)
+
+      JSON.parse(File.read(metadata_path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    def save_session_metadata(session_id, metadata)
+      ensure_session_directory(session_id)
+      metadata_path = File.join(session_directory(session_id), 'metadata.json')
+      File.write(metadata_path, JSON.pretty_generate(metadata))
+    end
+
+    def process_alive?(pid)
+      return false unless pid
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+  end
+end

data/rule.ko.md

@@ -8,6 +8,15 @@ Rails console과 마찬가지로 세션 내에서 실행한 결과는 유지되
 
 사용 전에는 `status`로 상태를 확인하고, 작업 종료 후에는 `stop`해야 합니다.
 
+## 설치 참고사항
+
+Gemfile이 있는 프로젝트에서는 `bundle exec`를 사용하는 것이 좋습니다:
+
+```bash
+$ bundle exec cone start
+$ bundle exec cone exec 'User.count'
+```
+
 ## Cone의 용도
 
 Cone은 디버깅, 데이터 탐색, 그리고 개발 보조 도구로 사용됩니다.
@@ -27,9 +36,21 @@ $ cone start # 서버 시작 (RAILS_ENV가 없으면 development)
 $ RAILS_ENV=test cone start # test 환경에서 console 시작
 ```
 
+시작 시 고유한 Session ID를 포함한 세션 정보가 표시됩니다:
+
+```bash
+$ cone start
+✓ Rails console started
+  Session ID: a1b2c3d4 (a1b2)
+  Target: cone
+  Environment: development
+  PID: 12345
+  Socket: /path/to/cone.socket
+```
+
 중지와 재시작 명령어도 제공합니다.
 
-Cone은 한 번에 하나의 세션만 제공하며, 실행 환경을 변경하려면 반드시 중지 후 재시작해야 합니다.
+Cone은 타겟당 한 번에 하나의 세션만 제공하며, 실행 환경을 변경하려면 반드시 중지 후 재시작해야 합니다.
 
 ```bash
 $ cone stop # 서버 중지
@@ -37,6 +58,51 @@ $ cone stop # 서버 중지
 
 작업을 마치면 반드시 종료해 주세요.
 
+## 세션 관리
+
+### 세션 목록 보기
+
+```bash
+$ cone ls                    # 활성 세션만 표시
+$ cone ls -a                 # 종료된 세션 포함 전체 표시
+```
+
+출력 예시:
+```
+ACTIVE SESSIONS:
+
+  ID       TARGET       ENV          STATUS    UPTIME     COMMANDS
+  a1b2     cone         development  running   2h 15m     42
+  e5f6     api          production   running   1h 30m     15
+
+Usage: cone exec -t TARGET CODE
+       cone exec --session ID CODE
+```
+
+### 세션 히스토리
+
+세션별 명령어 히스토리를 조회합니다:
+
+```bash
+$ cone history                    # 현재 세션 히스토리
+$ cone history -t api             # 'api' 타겟의 히스토리
+$ cone history --session a1b2     # 특정 세션 ID의 히스토리
+$ cone history -n 10              # 최근 10개 명령어
+$ cone history --today            # 오늘 실행한 명령어만
+$ cone history --failed           # 실패한 명령어만
+$ cone history --grep User        # 패턴으로 필터링
+$ cone history --json             # JSON 형식으로 출력
+```
+
+### 세션 삭제
+
+```bash
+$ cone rm a1b2                    # 종료된 세션 ID로 삭제
+$ cone rm -f a1b2                 # 강제 삭제 (실행 중이면 중지 후 삭제)
+$ cone prune                      # 종료된 모든 세션 삭제
+$ cone prune --yes                # 확인 없이 삭제
+```
+
 ## 실행 모드
 
 Cone은 세 가지 실행 모드를 지원합니다. `--mode` 옵션으로 지정할 수 있습니다.
@@ -82,10 +148,13 @@ mode: embed-rails
 ```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
+  Session ID: a1b2c3d4 (a1b2)
+  Target: cone
+  Environment: development
+  PID: 12345
+  Uptime: 2h 15m
+  Commands: 42
+  Socket: /path/to/cone.socket
 ```
 
 ## 코드 실행