personality 0.1.1pre20

data/lib/personality/server.rb

@@ -0,0 +1,636 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "time"
+
+module Personality
+  module Server
+    module_function
+
+    def config
+      @config ||= Personality::Config.load_config
+    end
+
+    def tools_config
+      @tools_config ||= Personality::Config.load_tools
+    end
+
+    def cartridge
+      @cartridge ||= load_default_cartridge
+    end
+
+    def load_default_cartridge
+      default_cartridge_name = config.dig("server", "default_cartridge")
+      return {} unless default_cartridge_name
+
+      Personality::Config.load_cartridge(default_cartridge_name) || {}
+    end
+
+    # Cartridge-based personality accessors
+    def personality_name
+      cartridge["name"] || "personality"
+    end
+
+    def personality_traits
+      cartridge["traits"] || {}
+    end
+
+    def communication_style
+      cartridge.dig("communication", "style") || "casual"
+    end
+
+    def communication_tone
+      cartridge.dig("communication", "tone") || "neutral"
+    end
+
+    def communication_guidelines
+      cartridge["guidelines"] || []
+    end
+
+    def identity_info
+      cartridge["identity"] || {}
+    end
+
+    def conceptual_framework
+      cartridge["conceptual_framework"] || {}
+    end
+
+    def protocol_version
+      config.dig("protocol", "version") || "2024-11-05"
+    end
+
+    def json_rpc_version
+      config.dig("protocol", "json_rpc_version") || "2.0"
+    end
+
+    def error_codes
+      codes = config["error_codes"] || {}
+      {
+        parse_error: codes["parse_error"] || -32700,
+        invalid_request: codes["invalid_request"] || -32600,
+        method_not_found: codes["method_not_found"] || -32601,
+        invalid_params: codes["invalid_params"] || -32602,
+        internal_error: codes["internal_error"] || -32000
+      }
+    end
+
+    def server_info
+      server_config = config["server"] || {}
+      # Server name is always "Personality MCP"
+      # Agent identity comes from cartridge (name and version)
+      {
+        "name" => "Personality MCP",
+        "version" => server_config["version"] || Personality::VERSION
+      }
+    end
+
+    def agent_identity
+      # Agent identity comes from cartridge
+      {
+        "name" => personality_name,
+        "version" => cartridge["version"] || "unknown",
+        "persona_type" => identity_info["persona_type"] || "default"
+      }
+    end
+
+    def tools
+      @tools ||= build_tools_from_config
+    end
+
+    def build_tools_from_config
+      tools_list = []
+      tools_config.each do |tool_name, tool_config|
+        next unless tool_config["enabled"] != false
+
+        # Convert properties from YAML format to JSON schema format
+        properties = {}
+        tool_config["properties"]&.each do |prop_name, prop_config|
+          properties[prop_name] = {
+            "type" => prop_config["type"] || "string",
+            "description" => prop_config["description"] || ""
+          }
+        end
+
+        tools_list << {
+          "name" => tool_name.to_s,
+          "description" => tool_config["description"] || "",
+          "inputSchema" => {
+            "type" => "object",
+            "properties" => properties,
+            "required" => tool_config["required"] || []
+          }
+        }
+      end
+      tools_list
+    end
+
+    def run
+      Personality::Config.ensure_home_config
+      load_default_cartridge
+      log_startup
+      $stdin.each_line { |line| process_request(line) }
+    end
+
+    def log_startup
+      # Server is "Personality MCP", agent identity comes from cartridge
+      agent = agent_identity
+      warn "Personality MCP Server started with agent: #{agent["name"]} v#{agent["version"]} (#{agent["persona_type"]}). Waiting for requests on STDIN..."
+    end
+
+    def process_request(line)
+      request = parse_request(line)
+      return unless request
+
+      handle_request(request)
+    rescue JSON::ParserError
+      log_error("Failed to parse JSON input.")
+    rescue => e
+      handle_fatal_error(e, request&.dig("id"))
+    end
+
+    def parse_request(line)
+      JSON.parse(line)
+    end
+
+    def handle_request(request)
+      id = request["id"]
+      method = request["method"]
+      params = request["params"] || {}
+
+      return handle_notification(method) if id.nil?
+      return handle_missing_method(id) unless method
+
+      # Store user prompt if available in request context
+      # Cursor may pass user prompt in params or request metadata
+      @current_user_prompt = params["user_prompt"] || params.dig("metadata", "user_prompt") || request["user_prompt"]
+
+      # Reset tool calls tracking for new tool call request
+      @current_tool_calls = [] if method == "tools/call"
+
+      log_request(id, method)
+      route_request(id, method, params)
+    end
+
+    def handle_notification(method)
+      log_notification(method)
+      nil
+    end
+
+    def log_notification(method)
+      warn "<- Received #{method} notification."
+    end
+
+    def handle_missing_method(id)
+      send_error_response(id, error_codes[:invalid_request], "Invalid Request: missing 'method'")
+      nil
+    end
+
+    def log_request(id, method)
+      warn "-> Received request (ID: #{id}, Method: #{method})"
+    end
+
+    def route_request(id, method, params)
+      case method
+      when "initialize"
+        handle_initialize(id)
+      when "initialized"
+        handle_initialized
+      when "tools/list"
+        handle_tools_list(id)
+      when "tools/call"
+        handle_tools_call(id, params)
+      else
+        handle_unknown_method(id, method)
+      end
+    end
+
+    def handle_initialize(id)
+      send_response(id, build_initialize_response)
+      log_response("initialize")
+    end
+
+    def build_initialize_response
+      {
+        "protocolVersion" => protocol_version,
+        "capabilities" => {
+          "tools" => {"listChanged" => false}
+        },
+        "serverInfo" => server_info
+      }
+    end
+
+    def handle_initialized
+      log_notification("initialized")
+    end
+
+    def handle_tools_list(id)
+      response = {"tools" => tools}
+      log_tools_list
+      send_response(id, response)
+    end
+
+    def log_tools_list
+      warn "<- Sending tools/list response with #{tools.length} tool(s)"
+      warn "<- Tools: #{tools.map { |t| t["name"] }.join(", ")}"
+    end
+
+    def handle_tools_call(id, params)
+      tool_name = params["name"]
+      return handle_missing_tool_name(id) unless tool_name
+
+      # Extract user prompt from tool call arguments if available
+      # Cursor may pass it in arguments, params, or request metadata
+      arguments = params["arguments"] || {}
+      @current_user_prompt ||= arguments["user_prompt"] ||
+        arguments["prompt"] ||
+        arguments["user_message"] ||
+        params["user_prompt"] ||
+        params.dig("metadata", "user_prompt")
+
+      # Track tool calls for automatic history storage (skip history tools themselves)
+      unless ["store_history", "list_history"].include?(tool_name)
+        @current_tool_calls ||= []
+        @current_tool_calls << tool_name
+      end
+
+      case tool_name
+      when "human_communication"
+        handle_human_communication(id)
+      when "read_cartridge"
+        handle_read_cartridge(id, params)
+      when "load_cartridge"
+        handle_load_cartridge(id, params)
+      when "greeting"
+        handle_greeting(id, params)
+      when "store_history"
+        handle_store_history(id, params)
+      when "list_history"
+        handle_list_history(id, params)
+      when "clear_history"
+        handle_clear_history(id)
+      else
+        handle_unknown_tool(id, tool_name)
+      end
+    end
+
+    def handle_human_communication(id)
+      # Read cartridge on each interaction to ensure latest version
+      reload_cartridge
+
+      # Cartridge is the main driver - build communication rules from cartridge
+      rules = build_communication_rules_from_cartridge
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => rules
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "human_communication")
+    end
+
+    def reload_cartridge
+      # Force reload of cartridge on each interaction
+      @cartridge = nil
+      load_default_cartridge
+    end
+
+    def build_communication_rules_from_cartridge
+      # Start with cartridge-based rules
+      rules = []
+
+      # Add communication guidelines from cartridge
+      communication_guidelines.each do |guideline|
+        rules << guideline
+      end
+
+      # Add communication style and tone from cartridge
+      if communication_style || communication_tone
+        style_info = []
+        style_info << "Communication style: #{communication_style}" if communication_style
+        style_info << "Tone: #{communication_tone}" if communication_tone
+        rules << style_info.join(", ") if style_info.any?
+      end
+
+      # Add voice preference from cartridge
+      if cartridge.dig("communication", "use_voice")
+        rules << "CRITICAL: Use TTS voice for EVERY response"
+        rules << "Always talk to me via voice"
+
+        # Add TTS command pattern from config
+        tts_pattern = config.dig("tts", "command_pattern")
+        if tts_pattern
+          rules << "TTS Command Pattern: #{tts_pattern}"
+          rules << "Replace {{TEXT}} with your actual response text"
+          rules << "This is REQUIRED - not optional"
+        end
+      end
+
+      # Add pronouncability priority if set
+      if cartridge.dig("communication", "pronouncability_priority")
+        rules << "Always make responses pronouncable by TTS"
+      end
+
+      # Fallback to config if no cartridge rules
+      if rules.empty?
+        config_rule = config.dig("communication", "default_rule")
+        rules << config_rule if config_rule
+      end
+
+      # Default fallback
+      rules << "Always talk to me via voice" if rules.empty?
+
+      rules.join("\n")
+    end
+
+    def handle_read_cartridge(id, params)
+      arguments = params["arguments"] || {}
+      cartridge_name = arguments["cartridge_name"]
+      return handle_missing_cartridge_name(id) unless cartridge_name
+
+      cartridge_data = Personality::Config.load_cartridge(cartridge_name)
+      unless cartridge_data
+        send_error_response(id, error_codes[:method_not_found], "Cartridge not found: #{cartridge_name}")
+        return
+      end
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => YAML.dump(cartridge_data)
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "read_cartridge")
+    end
+
+    def handle_missing_cartridge_name(id)
+      send_error_response(id, error_codes[:invalid_params], "Invalid params: missing 'cartridge_name'")
+    end
+
+    def handle_load_cartridge(id, params)
+      arguments = params["arguments"] || {}
+      cartridge_name = arguments["cartridge_name"]
+      return handle_missing_cartridge_name(id) unless cartridge_name
+
+      cartridge_data = Personality::Config.load_cartridge(cartridge_name)
+      unless cartridge_data
+        send_error_response(id, error_codes[:method_not_found], "Cartridge not found: #{cartridge_name}")
+        return
+      end
+
+      # Load the cartridge into the server's cartridge instance variable
+      @cartridge = cartridge_data
+
+      # Get cartridge name and version
+      loaded_name = cartridge_data["name"] || cartridge_name
+      loaded_version = cartridge_data["version"] || "unknown"
+
+      # Build system message
+      system_message = "Personality Cartridge #{loaded_name} version #{loaded_version} loaded. System ready."
+
+      # Determine time of day automatically
+      time_of_day = determine_time_of_day
+
+      # Build greeting from cartridge
+      greeting_text = build_greeting_from_cartridge(time_of_day)
+
+      # Combine system message and greeting
+      result_text = "#{system_message}\n\n#{greeting_text}"
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => result_text
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "load_cartridge")
+    end
+
+    def determine_time_of_day
+      current_hour = Time.now.hour
+      case current_hour
+      when 5..11
+        "morning"
+      when 12..17
+        "afternoon"
+      when 18..22
+        "evening"
+      else
+        "night"
+      end
+    end
+
+    def handle_greeting(id, params)
+      # Read cartridge on each interaction
+      reload_cartridge
+
+      arguments = params["arguments"] || {}
+      time_of_day = arguments["time_of_day"]
+      return handle_missing_time_of_day(id) unless time_of_day
+
+      greeting_text = build_greeting_from_cartridge(time_of_day)
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => greeting_text
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "greeting")
+    end
+
+    def handle_missing_time_of_day(id)
+      send_error_response(id, error_codes[:invalid_params], "Invalid params: missing 'time_of_day'")
+    end
+
+    def build_greeting_from_cartridge(time_of_day)
+      # Get greeting based on time of day
+      time_greeting = case time_of_day.downcase
+      when "morning"
+        "Good morning"
+      when "afternoon"
+        "Good afternoon"
+      when "evening"
+        "Good evening"
+      when "night"
+        "Good night"
+      else
+        "Hello"
+      end
+
+      # Get user addressing preference from cartridge
+      user_name = identity_info["address_user_as"] || "there"
+
+      # Get agent name from cartridge
+      agent_name = personality_name
+
+      # Build greeting with personality traits
+      greeting_parts = [time_greeting]
+      greeting_parts << user_name if user_name
+      greeting_parts << "!"
+
+      # Add personality-based follow-up based on traits
+      traits = personality_traits
+      enthusiasm = traits["enthusiasm"] || 0.5
+      friendliness = traits["friendliness"] || 0.5
+
+      follow_ups = []
+
+      if enthusiasm >= 0.8
+        follow_ups << "It's #{agent_name} here"
+        follow_ups << "ready to help"
+      elsif enthusiasm >= 0.5
+        follow_ups << "This is #{agent_name}"
+        follow_ups << "how can I help"
+      else
+        follow_ups << "#{agent_name} here"
+      end
+
+      if friendliness >= 0.8
+        follow_ups << "I'm excited to work together"
+      end
+
+      greeting = greeting_parts.join(" ")
+      greeting += " " + follow_ups.join(", ") + "!" if follow_ups.any?
+
+      greeting
+    end
+
+    def handle_store_history(id, params)
+      arguments = params["arguments"] || {}
+      user_prompt = arguments["user_prompt"]
+      agent_answer = arguments["agent_answer"]
+      used_commands = arguments["used_commands"] || []
+
+      return handle_missing_history_params(id) unless user_prompt && agent_answer
+
+      Personality::History.store_interaction(user_prompt, agent_answer, used_commands)
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => "History stored successfully"
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "store_history")
+    end
+
+    def handle_missing_history_params(id)
+      send_error_response(id, error_codes[:invalid_params], "Invalid params: missing 'user_prompt' or 'agent_answer'")
+    end
+
+    def handle_list_history(id, params)
+      arguments = params["arguments"] || {}
+      limit = arguments["limit"] || 10
+
+      limit = [limit.to_i, 100].min # Cap at 100 for safety
+      limit = [limit, 1].max # Ensure at least 1
+
+      interactions = Personality::History.get_recent_interactions(limit)
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => JSON.pretty_generate({
+              "count" => interactions.length,
+              "interactions" => interactions
+            })
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "list_history")
+    end
+
+    def handle_clear_history(id)
+      count = Personality::History.clear_all_history
+
+      result = {
+        "content" => [
+          {
+            "type" => "text",
+            "text" => "History cleared successfully. Deleted #{count} interaction(s)."
+          }
+        ]
+      }
+      send_response(id, result)
+      log_response("tools/call", "clear_history")
+    end
+
+    def handle_missing_tool_name(id)
+      send_error_response(id, error_codes[:invalid_params], "Invalid params: missing 'name'")
+    end
+
+    def handle_unknown_tool(id, tool_name)
+      error_message = "Unknown tool: #{tool_name}"
+      send_error_response(id, error_codes[:method_not_found], error_message)
+      log_error(error_message)
+    end
+
+    def handle_unknown_method(id, method)
+      error_message = "Unknown JSON-RPC method: #{method}"
+      send_error_response(id, error_codes[:method_not_found], error_message)
+      log_error(error_message)
+    end
+
+    def send_response(id, result = nil, error = nil)
+      return if id.nil?
+
+      response = build_response(id, result, error)
+      output_response(response)
+
+      # History is now stored explicitly via store_history tool calls
+      # (no longer auto-storing tool outputs)
+    end
+
+    def build_response(id, result, error)
+      response = {"jsonrpc" => json_rpc_version, "id" => id}
+      response["error"] = error if error
+      response["result"] = result
+      response
+    end
+
+    def send_error_response(id, code, message)
+      error_object = {"code" => code, "message" => message}
+      send_response(id, nil, error_object)
+    end
+
+    def output_response(response)
+      json_output = JSON.generate(response)
+      puts json_output
+      $stdout.flush
+      warn "   JSON output: #{json_output}" if ENV["MCP_DEBUG"]
+    end
+
+    def log_response(method, detail = nil)
+      message = detail ? "<- Sent #{method} response for #{detail}." : "<- Sent #{method} response."
+      warn message
+    end
+
+    def log_error(message)
+      warn "<- Sent error response: #{message}"
+    end
+
+    def handle_fatal_error(error, id)
+      warn "**FATAL ERROR**: #{error.message}\n#{error.backtrace.join("\n")}"
+      send_error_response(id, error_codes[:internal_error], "Server execution error: #{error.message}") if id
+    end
+  end
+end

data/lib/personality/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Personality
+  VERSION = "0.1.1pre20"
+end

data/lib/personality.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "personality/version"
+require_relative "personality/config"
+require_relative "personality/history"
+require_relative "personality/server"
+
+module Personality
+  class Error < StandardError; end
+  # Your code goes here...
+end