personality 0.1.0

data/lib/personality/mcp/server.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require "mcp"
+require "mcp/transports/stdio"
+require "json"
+require_relative "../db"
+require_relative "../memory"
+require_relative "../indexer"
+require_relative "../cart"
+
+module Personality
+  module MCP
+    class Server
+      def self.run
+        DB.migrate!
+        new.start
+      end
+
+      def initialize
+        @server = ::MCP::Server.new(
+          name: "personality",
+          version: Personality::VERSION
+        )
+        @server.server_context = {}
+        register_tools
+        register_resources
+      end
+
+      def start
+        transport = ::MCP::Transports::StdioTransport.new(@server)
+        transport.open
+      end
+
+      private
+
+      def tool_response(result)
+        ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+      end
+
+      # === Memory Tools ===
+
+      def register_memory_tools
+        @server.define_tool(
+          name: "memory.store",
+          description: "Store a memory with subject and content. Automatically generates embedding.",
+          input_schema: {
+            type: "object",
+            properties: {
+              subject: {type: "string", description: "Memory subject/category"},
+              content: {type: "string", description: "Memory content to store"},
+              metadata: {type: "object", description: "Additional metadata"}
+            },
+            required: %w[subject content]
+          }
+        ) do |subject:, content:, server_context:, **opts|
+          result = Memory.new.store(subject: subject, content: content, metadata: opts.fetch(:metadata, {}))
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "memory.recall",
+          description: "Recall memories by semantic similarity to a query.",
+          input_schema: {
+            type: "object",
+            properties: {
+              query: {type: "string", description: "Query to search for"},
+              limit: {type: "integer", description: "Max results (default: 5)"},
+              subject: {type: "string", description: "Filter by subject"}
+            },
+            required: %w[query]
+          }
+        ) do |query:, server_context:, **opts|
+          result = Memory.new.recall(query: query, limit: opts.fetch(:limit, 5), subject: opts[:subject])
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "memory.search",
+          description: "Search memories by subject or metadata.",
+          input_schema: {
+            type: "object",
+            properties: {
+              subject: {type: "string", description: "Subject to search"},
+              limit: {type: "integer", description: "Max results"}
+            }
+          }
+        ) do |server_context:, **opts|
+          result = Memory.new.search(subject: opts[:subject], limit: opts.fetch(:limit, 20))
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "memory.forget",
+          description: "Delete a memory by ID.",
+          input_schema: {
+            type: "object",
+            properties: {
+              id: {type: "integer", description: "Memory ID to delete"}
+            },
+            required: %w[id]
+          }
+        ) do |id:, server_context:, **|
+          result = Memory.new.forget(id: id)
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "memory.list",
+          description: "List all memory subjects and counts.",
+          input_schema: {type: "object", properties: {}}
+        ) do |server_context:, **|
+          result = Memory.new.list
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+      end
+
+      # === Index Tools ===
+
+      def register_index_tools
+        @server.define_tool(
+          name: "index.code",
+          description: "Index code files in a directory for semantic search.",
+          input_schema: {
+            type: "object",
+            properties: {
+              path: {type: "string", description: "Directory path to index"},
+              project: {type: "string", description: "Project name for grouping"},
+              extensions: {type: "array", items: {type: "string"}, description: "File extensions to include"}
+            },
+            required: %w[path]
+          }
+        ) do |path:, server_context:, **opts|
+          result = Indexer.new.index_code(path: path, project: opts[:project], extensions: opts[:extensions])
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "index.docs",
+          description: "Index documentation files for semantic search.",
+          input_schema: {
+            type: "object",
+            properties: {
+              path: {type: "string", description: "Directory path to index"},
+              project: {type: "string", description: "Project name"}
+            },
+            required: %w[path]
+          }
+        ) do |path:, server_context:, **opts|
+          result = Indexer.new.index_docs(path: path, project: opts[:project])
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "index.search",
+          description: "Search indexed code and docs by semantic similarity.",
+          input_schema: {
+            type: "object",
+            properties: {
+              query: {type: "string", description: "Search query"},
+              type: {type: "string", enum: %w[code docs all], description: "What to search"},
+              project: {type: "string", description: "Filter by project"},
+              limit: {type: "integer", description: "Max results"}
+            },
+            required: %w[query]
+          }
+        ) do |query:, server_context:, **opts|
+          result = Indexer.new.search(
+            query: query,
+            type: (opts[:type] || "all").to_sym,
+            project: opts[:project],
+            limit: opts.fetch(:limit, 10)
+          )
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "index.status",
+          description: "Show indexing status and statistics.",
+          input_schema: {
+            type: "object",
+            properties: {
+              project: {type: "string", description: "Filter by project"}
+            }
+          }
+        ) do |server_context:, **opts|
+          result = Indexer.new.status(project: opts[:project])
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "index.clear",
+          description: "Clear index for a project or all.",
+          input_schema: {
+            type: "object",
+            properties: {
+              project: {type: "string", description: "Project to clear (omit for all)"},
+              type: {type: "string", enum: %w[code docs all], description: "What to clear"}
+            }
+          }
+        ) do |server_context:, **opts|
+          result = Indexer.new.clear(project: opts[:project], type: (opts[:type] || "all").to_sym)
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+      end
+
+      # === Cart Tools ===
+
+      def register_cart_tools
+        @server.define_tool(
+          name: "cart.list",
+          description: "List all personas.",
+          input_schema: {type: "object", properties: {}}
+        ) do |server_context:, **|
+          result = {carts: Cart.list}
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "cart.use",
+          description: "Switch active persona.",
+          input_schema: {
+            type: "object",
+            properties: {
+              tag: {type: "string", description: "Persona tag"}
+            },
+            required: %w[tag]
+          }
+        ) do |tag:, server_context:, **|
+          result = Cart.use(tag)
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+
+        @server.define_tool(
+          name: "cart.create",
+          description: "Create a new persona.",
+          input_schema: {
+            type: "object",
+            properties: {
+              tag: {type: "string", description: "Persona tag"},
+              name: {type: "string", description: "Display name"},
+              type: {type: "string", description: "Persona type"}
+            },
+            required: %w[tag]
+          }
+        ) do |tag:, server_context:, **opts|
+          result = Cart.create(tag, name: opts[:name], type: opts[:type])
+          ::MCP::Tool::Response.new([{type: "text", text: JSON.generate(result)}])
+        end
+      end
+
+      # === Resources ===
+
+      def register_resources
+        resources = [
+          ::MCP::Resource.new(
+            uri: "memory://subjects",
+            name: "memory-subjects",
+            description: "All memory subjects with counts",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "memory://stats",
+            name: "memory-stats",
+            description: "Total memories, subjects, date range",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "memory://recent",
+            name: "memory-recent",
+            description: "Most recent 10 memories",
+            mime_type: "application/json"
+          )
+        ]
+        @server.resources = resources
+
+        @server.resources_read_handler do |params|
+          uri = params[:uri]
+          result = read_memory_resource(uri)
+          [{uri: uri, mimeType: "application/json", text: JSON.generate(result)}]
+        end
+      end
+
+      def register_tools
+        register_memory_tools
+        register_index_tools
+        register_cart_tools
+      end
+
+      def read_memory_resource(uri)
+        db = DB.connection
+        cart = Cart.active
+
+        case uri
+        when "memory://subjects"
+          rows = db.execute("SELECT subject, COUNT(*) AS count FROM memories WHERE cart_id = ? GROUP BY subject ORDER BY count DESC", [cart[:id]])
+          {subjects: rows.map { |r| {subject: r["subject"], count: r["count"]} }}
+
+        when "memory://stats"
+          total = db.execute("SELECT COUNT(*) AS c FROM memories WHERE cart_id = ?", [cart[:id]]).dig(0, "c") || 0
+          subjects = db.execute("SELECT COUNT(DISTINCT subject) AS c FROM memories WHERE cart_id = ?", [cart[:id]]).dig(0, "c") || 0
+          dates = db.execute("SELECT MIN(created_at) AS oldest, MAX(created_at) AS newest FROM memories WHERE cart_id = ?", [cart[:id]]).first
+          {cart: cart[:tag], total_memories: total, total_subjects: subjects, oldest: dates&.fetch("oldest", nil), newest: dates&.fetch("newest", nil)}
+
+        when "memory://recent"
+          rows = db.execute("SELECT id, subject, content, created_at FROM memories WHERE cart_id = ? ORDER BY created_at DESC LIMIT 10", [cart[:id]])
+          {memories: rows.map { |r| {id: r["id"], subject: r["subject"], content: r["content"], created_at: r["created_at"]} }}
+
+        else
+          {error: "Unknown resource: #{uri}"}
+        end
+      end
+    end
+  end
+end

data/lib/personality/memory.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "db"
+require_relative "embedding"
+require_relative "cart"
+
+module Personality
+  class Memory
+    attr_reader :cart_id
+
+    def initialize(cart_id: nil)
+      @cart_id = cart_id || Cart.active[:id]
+    end
+
+    def store(subject:, content:, metadata: {})
+      db = DB.connection
+      embedding = Embedding.generate(content)
+
+      db.execute(
+        "INSERT INTO memories (cart_id, subject, content, metadata) VALUES (?, ?, ?, ?)",
+        [cart_id, subject, content, JSON.generate(metadata)]
+      )
+      memory_id = db.last_insert_row_id
+
+      unless embedding.empty?
+        db.execute(
+          "INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)",
+          [memory_id, embedding.to_json]
+        )
+      end
+
+      {id: memory_id, subject: subject}
+    end
+
+    def recall(query:, limit: 5, subject: nil)
+      embedding = Embedding.generate(query)
+      return {memories: []} if embedding.empty?
+
+      db = DB.connection
+
+      if subject
+        rows = db.execute(<<~SQL, [embedding.to_json, limit, cart_id, subject])
+          SELECT m.id, m.subject, m.content, m.metadata, m.created_at, v.distance
+          FROM vec_memories v
+          INNER JOIN memories m ON m.id = v.memory_id
+          WHERE v.embedding MATCH ? AND k = ?
+            AND m.cart_id = ? AND m.subject = ?
+          ORDER BY v.distance
+        SQL
+      else
+        rows = db.execute(<<~SQL, [embedding.to_json, limit, cart_id])
+          SELECT m.id, m.subject, m.content, m.metadata, m.created_at, v.distance
+          FROM vec_memories v
+          INNER JOIN memories m ON m.id = v.memory_id
+          WHERE v.embedding MATCH ? AND k = ?
+            AND m.cart_id = ?
+          ORDER BY v.distance
+        SQL
+      end
+
+      memories = rows.map { |r| memory_row_to_hash(r) }
+      {memories: memories}
+    end
+
+    def search(subject: nil, limit: 20)
+      db = DB.connection
+
+      if subject
+        rows = db.execute(
+          "SELECT id, subject, content, created_at FROM memories WHERE cart_id = ? AND subject LIKE ? ORDER BY created_at DESC LIMIT ?",
+          [cart_id, "%#{subject}%", limit]
+        )
+      else
+        rows = db.execute(
+          "SELECT id, subject, content, created_at FROM memories WHERE cart_id = ? ORDER BY created_at DESC LIMIT ?",
+          [cart_id, limit]
+        )
+      end
+
+      memories = rows.map do |r|
+        {id: r["id"], subject: r["subject"], content: r["content"], created_at: r["created_at"]}
+      end
+      {memories: memories}
+    end
+
+    def forget(id:)
+      db = DB.connection
+      db.execute("DELETE FROM vec_memories WHERE memory_id = ?", [id])
+      db.execute("DELETE FROM memories WHERE id = ? AND cart_id = ?", [id, cart_id])
+      deleted = db.changes > 0
+      {deleted: deleted}
+    end
+
+    def list
+      db = DB.connection
+      rows = db.execute(
+        "SELECT subject, COUNT(*) AS count FROM memories WHERE cart_id = ? GROUP BY subject ORDER BY count DESC",
+        [cart_id]
+      )
+      subjects = rows.map { |r| {subject: r["subject"], count: r["count"]} }
+      {subjects: subjects}
+    end
+
+    private
+
+    def memory_row_to_hash(row)
+      {
+        id: row["id"],
+        subject: row["subject"],
+        content: row["content"],
+        metadata: safe_parse_json(row["metadata"]),
+        created_at: row["created_at"],
+        distance: row["distance"]
+      }
+    end
+
+    def safe_parse_json(str)
+      return {} if str.nil? || str.empty?
+      JSON.parse(str)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/personality/tts.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Personality
+  module TTS
+    VOICES_DIR = File.join(Dir.home, ".local", "share", "psn", "voices")
+    DATA_DIR = File.join(Dir.home, ".local", "share", "personality", "data")
+    DEFAULT_VOICE = "en_US-lessac-medium"
+
+    PID_FILE = File.join(DATA_DIR, "tts.pid")
+    WAV_FILE = File.join(DATA_DIR, "tts_current.wav")
+    NATURAL_STOP_FLAG = File.join(DATA_DIR, "tts_natural_stop")
+
+    PIPER_VOICES_BASE_URL = "https://huggingface.co/rhasspy/piper-voices/resolve/main"
+
+    class << self
+      # --- Synthesis & Playback ---
+
+      def speak(text, voice: nil)
+        stop_current
+        voice ||= active_voice
+
+        model_path = find_voice(voice)
+        return {error: "Voice not found: #{voice}"} unless model_path
+
+        piper_bin = find_piper
+        return {error: "piper not installed"} unless piper_bin
+
+        FileUtils.mkdir_p(DATA_DIR)
+
+        # Synthesize to WAV
+        stdout, stderr, status = Open3.capture3(
+          piper_bin, "--model", model_path, "--output_file", WAV_FILE,
+          stdin_data: text
+        )
+        return {error: "piper failed: #{stderr}"} unless status.success?
+
+        # Play audio (macOS: afplay, Linux: aplay)
+        player = player_command
+        return {error: "No audio player found"} unless player
+
+        pid = spawn(player, WAV_FILE, [:out, :err] => "/dev/null")
+        save_pid(pid)
+
+        {speaking: true, voice: voice, pid: pid}
+      end
+
+      def speak_and_wait(text, voice: nil)
+        result = speak(text, voice: voice)
+        return result if result[:error]
+
+        Process.wait(result[:pid])
+        clear_pid
+        result.merge(speaking: false)
+      rescue Errno::ECHILD
+        clear_pid
+        result
+      end
+
+      def stop_current
+        return false unless File.exist?(PID_FILE)
+
+        pid = File.read(PID_FILE).strip.to_i
+        Process.kill("TERM", pid)
+        clear_pid
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        clear_pid
+        false
+      end
+
+      # --- Interrupt Protocol ---
+
+      def mark_natural_stop
+        FileUtils.mkdir_p(DATA_DIR)
+        FileUtils.touch(NATURAL_STOP_FLAG)
+      end
+
+      def interrupt_check
+        if File.exist?(NATURAL_STOP_FLAG)
+          File.delete(NATURAL_STOP_FLAG)
+          {action: :continue, reason: "natural_stop"}
+        else
+          stopped = stop_current
+          {action: :stopped, reason: "user_interrupt", was_playing: stopped}
+        end
+      end
+
+      def clear_natural_stop_flag
+        File.delete(NATURAL_STOP_FLAG) if File.exist?(NATURAL_STOP_FLAG)
+      end
+
+      # --- Voice Management ---
+
+      def find_voice(name)
+        path = File.join(VOICES_DIR, "#{name}.onnx")
+        File.exist?(path) ? path : nil
+      end
+
+      def list_voices
+        return [] unless Dir.exist?(VOICES_DIR)
+
+        Dir.glob(File.join(VOICES_DIR, "*.onnx")).map do |path|
+          name = File.basename(path, ".onnx")
+          size_mb = File.size(path) / (1024.0 * 1024)
+          {name: name, path: path, size_mb: size_mb.round(1)}
+        end.sort_by { |v| v[:name].downcase }
+      end
+
+      def download_voice(voice_name)
+        FileUtils.mkdir_p(VOICES_DIR)
+
+        model_path = File.join(VOICES_DIR, "#{voice_name}.onnx")
+        config_path = File.join(VOICES_DIR, "#{voice_name}.onnx.json")
+
+        return {exists: true, voice: voice_name} if File.exist?(model_path)
+
+        parts = voice_name.split("-")
+        return {error: "Invalid voice format"} if parts.length < 2
+
+        lang = parts[0]         # en_US
+        lang_short = lang.split("_")[0]  # en
+        name = parts[1]         # lessac
+        quality = parts[2] || "medium"
+
+        model_url = "#{PIPER_VOICES_BASE_URL}/#{lang_short}/#{lang}/#{name}/#{quality}/#{voice_name}.onnx"
+        config_url = "#{PIPER_VOICES_BASE_URL}/#{lang_short}/#{lang}/#{name}/#{quality}/#{voice_name}.onnx.json"
+
+        require "net/http"
+        require "uri"
+
+        download_file(model_url, model_path)
+        download_file(config_url, config_path)
+
+        size_mb = File.size(model_path) / (1024.0 * 1024)
+        {installed: true, voice: voice_name, size_mb: size_mb.round(1)}
+      rescue => e
+        FileUtils.rm_f(model_path)
+        FileUtils.rm_f(config_path)
+        {error: "Download failed: #{e.message}"}
+      end
+
+      def active_voice
+        ENV.fetch("PERSONALITY_VOICE", DEFAULT_VOICE)
+      end
+
+      private
+
+      def find_piper
+        # Check common locations
+        [
+          File.join(Dir.home, ".local", "bin", "piper"),
+          `which piper 2>/dev/null`.strip
+        ].find { |p| !p.empty? && File.executable?(p) }
+      end
+
+      def player_command
+        if RUBY_PLATFORM.include?("darwin")
+          "afplay"
+        elsif system("which aplay > /dev/null 2>&1")
+          "aplay"
+        end
+      end
+
+      def save_pid(pid)
+        File.write(PID_FILE, pid.to_s)
+      end
+
+      def clear_pid
+        FileUtils.rm_f(PID_FILE)
+        FileUtils.rm_f(WAV_FILE)
+      end
+
+      def download_file(url, dest)
+        uri = URI.parse(url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          request = Net::HTTP::Get.new(uri)
+          http.request(request) do |response|
+            raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+            File.open(dest, "wb") do |file|
+              response.read_body { |chunk| file.write(chunk) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/personality/version.rb

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

data/lib/personality.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Personality
+  class Error < StandardError; end
+end
+
+require_relative "personality/version"
+require_relative "personality/db"
+require_relative "personality/embedding"
+require_relative "personality/chunker"
+require_relative "personality/hooks"
+require_relative "personality/context"
+require_relative "personality/cart"
+require_relative "personality/memory"
+require_relative "personality/tts"
+require_relative "personality/indexer"
+require_relative "personality/cli"