personality 0.1.0

data/lib/personality/embedding.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Personality
+  module Embedding
+    DEFAULT_URL = "http://localhost:11434"
+    DEFAULT_MODEL = "nomic-embed-text"
+    MAX_INPUT_LENGTH = 8000
+    DIMENSIONS = 768
+
+    class Error < Personality::Error; end
+
+    class << self
+      def generate(text, model: nil, url: nil)
+        truncated = text.to_s[0, MAX_INPUT_LENGTH]
+        return [] if truncated.empty?
+
+        ollama_url = url || ENV.fetch("OLLAMA_URL", DEFAULT_URL)
+        ollama_model = model || ENV.fetch("OLLAMA_MODEL", DEFAULT_MODEL)
+
+        uri = URI.join(ollama_url, "/api/embeddings")
+        body = {model: ollama_model, prompt: truncated}.to_json
+
+        response = Net::HTTP.post(uri, body, "Content-Type" => "application/json")
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise Error, "Ollama returned #{response.code}: #{response.body}"
+        end
+
+        result = JSON.parse(response.body)
+        embedding = result["embedding"]
+
+        unless embedding.is_a?(Array) && !embedding.empty?
+          raise Error, "Unexpected Ollama response: missing embedding"
+        end
+
+        embedding
+      end
+    end
+  end
+end

data/lib/personality/hooks.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Personality
+  module Hooks
+    LOG_DIR = File.join(Dir.home, ".config", "psn")
+    LOG_FILE = File.join(LOG_DIR, "hooks.jsonl")
+    CONFIG_FILE = File.join(LOG_DIR, "logging.toml")
+
+    DEFAULT_MAX_LENGTH = 50
+    DEFAULT_PRESERVE_FIELDS = %w[path file_path cwd transcript_path file directory].freeze
+    DEFAULT_PRESERVE_SUFFIXES = %w[_path _dir].freeze
+
+    HOOKS_JSON_TEMPLATE = {
+      hooks: {
+        PreToolUse: [{hooks: [{type: "command", command: "psn hooks pre-tool-use", timeout: 5000}]}],
+        PostToolUse: [
+          {matcher: "Read", hooks: [{type: "command", command: "psn context track-read", timeout: 5000}]},
+          {matcher: "Write|Edit", hooks: [{type: "command", command: "psn index hook", timeout: 30_000}]}
+        ],
+        Stop: [{hooks: [
+          {type: "command", command: "psn tts mark-natural-stop", timeout: 1000},
+          {type: "command", command: "psn memory save", timeout: 5000}
+        ]}],
+        SubagentStop: [{hooks: [{type: "command", command: "psn hooks subagent-stop", timeout: 5000}]}],
+        SessionStart: [{hooks: [{type: "command", command: "psn hooks session-start", timeout: 5000}]}],
+        SessionEnd: [{hooks: [
+          {type: "command", command: "psn hooks session-end", timeout: 5000},
+          {type: "command", command: "psn tts stop", timeout: 1000}
+        ]}],
+        UserPromptSubmit: [{hooks: [
+          {type: "command", command: "psn hooks user-prompt-submit", timeout: 5000},
+          {type: "command", command: "psn tts interrupt-check", timeout: 1000}
+        ]}],
+        PreCompact: [{hooks: [{type: "command", command: "psn memory save", timeout: 5000}]}],
+        Notification: [{hooks: [{type: "command", command: "psn hooks notification", timeout: 5000}]}]
+      }
+    }.freeze
+
+    class << self
+      def log(event, data = nil)
+        FileUtils.mkdir_p(LOG_DIR)
+
+        entry = {
+          ts: Time.now.utc.iso8601,
+          event: event,
+          session: ENV.fetch("CLAUDE_SESSION_ID", ""),
+          cwd: Dir.pwd
+        }
+
+        if data.is_a?(Hash)
+          data.each do |key, value|
+            next if key.to_s == "hook_event_name"
+            entry[key.to_sym] = process_value(key.to_s, value)
+          end
+        end
+
+        File.open(LOG_FILE, "a") { |f| f.puts(JSON.generate(entry)) }
+      rescue
+        nil # Silent fail — don't break hooks on logging errors
+      end
+
+      def read_stdin_json
+        return nil if $stdin.tty?
+        JSON.parse($stdin.read)
+      rescue JSON::ParserError, EOFError
+        nil
+      end
+
+      def generate_hooks_json
+        JSON.pretty_generate(HOOKS_JSON_TEMPLATE)
+      end
+
+      def truncate(value, max_length: nil)
+        max = max_length || config[:max_length]
+        return value if value.length <= max
+        "#{value[0, max - 3]}..."
+      end
+
+      def preserved_key?(key)
+        key_lower = key.downcase
+        return true if config[:preserve_fields].include?(key_lower)
+        config[:preserve_suffixes].any? { |suffix| key_lower.end_with?(suffix) }
+      end
+
+      def process_value(key, value)
+        case value
+        when nil then nil
+        when true, false then value
+        when Integer, Float then value
+        when String
+          preserved_key?(key) ? value : truncate(value)
+        when Hash
+          value.transform_keys(&:to_s).each_with_object({}) do |(k, v), h|
+            h[k] = process_value(k, v)
+          end
+        when Array
+          processed = value.first(5).map { |item| process_value(key, item) }
+          processed << "...+#{value.length - 5} more" if value.length > 5
+          processed
+        else
+          truncate(value.to_s)
+        end
+      end
+
+      def config
+        @config ||= load_config
+      end
+
+      def reset_config!
+        @config = nil
+      end
+
+      private
+
+      def load_config
+        cfg = {
+          max_length: DEFAULT_MAX_LENGTH,
+          preserve_fields: DEFAULT_PRESERVE_FIELDS.dup,
+          preserve_suffixes: DEFAULT_PRESERVE_SUFFIXES.dup
+        }
+
+        if File.exist?(CONFIG_FILE)
+          begin
+            require "toml-rb"
+            file_config = TomlRB.load_file(CONFIG_FILE)
+            if (t = file_config["truncation"])
+              cfg[:max_length] = t["max_length"] if t["max_length"]
+              cfg[:preserve_fields] = t["preserve_fields"] if t["preserve_fields"]
+              cfg[:preserve_suffixes] = t["preserve_suffixes"] if t["preserve_suffixes"]
+            end
+          rescue
+            # Use defaults on error
+          end
+        end
+
+        cfg
+      end
+    end
+  end
+end

data/lib/personality/indexer.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "db"
+require_relative "embedding"
+require_relative "chunker"
+
+module Personality
+  class Indexer
+    CODE_EXTENSIONS = %w[.py .rs .rb .js .ts .go .java .c .cpp .h].to_set.freeze
+    DOC_EXTENSIONS = %w[.md .txt .rst .adoc].to_set.freeze
+
+    def index_code(path:, project: nil, extensions: nil)
+      dir = File.expand_path(path)
+      proj = project || File.basename(dir)
+      exts = extensions ? extensions.map { |e| e.start_with?(".") ? e : ".#{e}" }.to_set : CODE_EXTENSIONS
+
+      index_files(dir, proj, exts, table: "code_chunks", vec_table: "vec_code", language: true)
+    end
+
+    def index_docs(path:, project: nil)
+      dir = File.expand_path(path)
+      proj = project || File.basename(dir)
+
+      index_files(dir, proj, DOC_EXTENSIONS, table: "doc_chunks", vec_table: "vec_docs", language: false)
+    end
+
+    def search(query:, type: :all, project: nil, limit: 10)
+      embedding = Embedding.generate(query)
+      return {results: []} if embedding.empty?
+
+      results = []
+      db = DB.connection
+
+      if type == :all || type == :code
+        results.concat(
+          search_table(db, "code_chunks", "vec_code", embedding, project: project, limit: limit, type: :code)
+        )
+      end
+
+      if type == :all || type == :docs
+        results.concat(
+          search_table(db, "doc_chunks", "vec_docs", embedding, project: project, limit: limit, type: :docs)
+        )
+      end
+
+      results.sort_by! { |r| r[:distance] }
+      {results: results.first(limit)}
+    end
+
+    def status(project: nil)
+      db = DB.connection
+
+      code_stats = count_by_project(db, "code_chunks", project)
+      doc_stats = count_by_project(db, "doc_chunks", project)
+
+      {code_index: code_stats, doc_index: doc_stats}
+    end
+
+    def clear(project: nil, type: :all)
+      db = DB.connection
+
+      if type == :all || type == :code
+        clear_table(db, "code_chunks", "vec_code", project)
+      end
+
+      if type == :all || type == :docs
+        clear_table(db, "doc_chunks", "vec_docs", project)
+      end
+
+      {cleared: type.to_s, project: project || "all"}
+    end
+
+    def index_single_file(file_path:, project: nil)
+      path = File.expand_path(file_path)
+      return unless File.exist?(path)
+
+      ext = File.extname(path).downcase
+      proj = project || File.basename(Dir.pwd)
+
+      if CODE_EXTENSIONS.include?(ext)
+        index_one_file(path, proj, "code_chunks", "vec_code", language: ext[1..])
+      elsif DOC_EXTENSIONS.include?(ext)
+        index_one_file(path, proj, "doc_chunks", "vec_docs", language: nil)
+      end
+    end
+
+    private
+
+    def index_files(dir, project, extensions, table:, vec_table:, language:)
+      indexed = 0
+      errors = []
+
+      Dir.glob(File.join(dir, "**", "*")).each do |file_path|
+        next unless File.file?(file_path)
+        next unless extensions.include?(File.extname(file_path).downcase)
+
+        begin
+          lang = language ? File.extname(file_path).downcase[1..] : nil
+          count = index_one_file(file_path, project, table, vec_table, language: lang)
+          indexed += count
+        rescue => e
+          errors << "#{file_path}: #{e.message}"
+        end
+      end
+
+      {indexed: indexed, project: project, errors: errors.first(5)}
+    end
+
+    def index_one_file(file_path, project, table, vec_table, language: nil)
+      content = File.read(file_path, encoding: "UTF-8")
+      return 0 if content.length < Chunker::MIN_LENGTH
+
+      db = DB.connection
+      chunks = Chunker.split(content)
+      count = 0
+
+      # Remove old chunks for this file
+      old_ids = db.execute(
+        "SELECT id FROM #{table} WHERE path = ? AND project = ?", [file_path, project]
+      ).map { |r| r["id"] }
+
+      old_ids.each do |id|
+        db.execute("DELETE FROM #{vec_table} WHERE chunk_id = ?", [id])
+        db.execute("DELETE FROM #{table} WHERE id = ?", [id])
+      end
+
+      chunks.each_with_index do |chunk, idx|
+        embedding = Embedding.generate(chunk)
+        next if embedding.empty?
+
+        if language
+          db.execute(
+            "INSERT INTO #{table} (path, content, language, project, chunk_index) VALUES (?, ?, ?, ?, ?)",
+            [file_path, chunk, language, project, idx]
+          )
+        else
+          db.execute(
+            "INSERT INTO #{table} (path, content, project, chunk_index) VALUES (?, ?, ?, ?)",
+            [file_path, chunk, project, idx]
+          )
+        end
+
+        chunk_id = db.last_insert_row_id
+        db.execute(
+          "INSERT INTO #{vec_table} (chunk_id, embedding) VALUES (?, ?)",
+          [chunk_id, embedding.to_json]
+        )
+        count += 1
+      end
+
+      count
+    end
+
+    def search_table(db, table, vec_table, embedding, project:, limit:, type:)
+      if project
+        rows = db.execute(<<~SQL, [embedding.to_json, limit, project])
+          SELECT c.id, c.path, c.content, c.project, v.distance
+          FROM #{vec_table} v
+          INNER JOIN #{table} c ON c.id = v.chunk_id
+          WHERE v.embedding MATCH ? AND k = ?
+            AND c.project = ?
+          ORDER BY v.distance
+        SQL
+      else
+        rows = db.execute(<<~SQL, [embedding.to_json, limit])
+          SELECT c.id, c.path, c.content, c.project, v.distance
+          FROM #{vec_table} v
+          INNER JOIN #{table} c ON c.id = v.chunk_id
+          WHERE v.embedding MATCH ? AND k = ?
+          ORDER BY v.distance
+        SQL
+      end
+
+      rows.map do |r|
+        {
+          type: type,
+          id: r["id"],
+          path: r["path"],
+          content: r["content"]&.slice(0, 500),
+          project: r["project"],
+          distance: r["distance"]
+        }
+      end
+    end
+
+    def count_by_project(db, table, project)
+      if project
+        db.execute(
+          "SELECT project, COUNT(*) AS count FROM #{table} WHERE project = ? GROUP BY project",
+          [project]
+        )
+      else
+        db.execute("SELECT project, COUNT(*) AS count FROM #{table} GROUP BY project")
+      end.map { |r| {project: r["project"], count: r["count"]} }
+    end
+
+    def clear_table(db, table, vec_table, project)
+      if project
+        ids = db.execute("SELECT id FROM #{table} WHERE project = ?", [project]).map { |r| r["id"] }
+        ids.each do |id|
+          db.execute("DELETE FROM #{vec_table} WHERE chunk_id = ?", [id])
+        end
+        db.execute("DELETE FROM #{table} WHERE project = ?", [project])
+      else
+        db.execute("DELETE FROM #{vec_table}")
+        db.execute("DELETE FROM #{table}")
+      end
+    end
+  end
+end

data/lib/personality/init.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "pastel"
+require "tty-spinner"
+require_relative "db"
+
+module Personality
+  class Init
+    DB_PATH = DB::DB_PATH
+
+    attr_reader :pastel, :auto_yes
+
+    def initialize(auto_yes: false)
+      @pastel = Pastel.new
+      @auto_yes = auto_yes
+    end
+
+    def run
+      puts pastel.bold("Personality Init")
+      puts pastel.dim("=" * 40)
+      puts
+
+      results = []
+      results << setup_database
+      results << check_ollama
+      results << check_nomic_embed
+      results << check_uv
+      results << check_piper
+
+      puts
+      puts pastel.bold("Summary")
+      puts pastel.dim("-" * 40)
+      results.each { |label, status| print_result(label, status) }
+      puts
+    end
+
+    private
+
+    # Step 1: Create sqlite-vec database
+    def setup_database
+      label = "sqlite-vec database"
+      puts pastel.bold("\n1. #{label}")
+
+      if File.exist?(DB_PATH)
+        puts "  #{pastel.green("exists")} #{DB_PATH}"
+        return [label, :exists]
+      end
+
+      unless confirm?("Create database at #{DB_PATH}?")
+        return [label, :skipped]
+      end
+
+      spinner = spin("Creating database")
+      begin
+        DB.migrate!
+        spinner.success(pastel.green("done"))
+        [label, :installed]
+      rescue => e
+        spinner.error(pastel.red("failed"))
+        puts "  #{pastel.red(e.message)}"
+        [label, :failed]
+      end
+    end
+
+    # Step 2: Check for Ollama
+    def check_ollama
+      label = "ollama"
+      puts pastel.bold("\n2. #{label}")
+
+      version = command_version("ollama", "--version")
+      if version
+        puts "  #{pastel.green("found")} #{version}"
+        @ollama_was_present = true
+        ensure_ollama_running
+        return [label, :exists]
+      end
+
+      @ollama_was_present = false
+      install_cmd = brew_available? ? "brew install ollama" : "curl -fsSL https://ollama.com/install.sh | sh"
+
+      unless confirm?("Ollama not found. Install via `#{install_cmd}`?")
+        return [label, :skipped]
+      end
+
+      spinner = spin("Installing ollama")
+      if run_command(install_cmd)
+        spinner.success(pastel.green("done"))
+        ensure_ollama_running
+        [label, :installed]
+      else
+        spinner.error(pastel.red("failed"))
+        [label, :failed]
+      end
+    end
+
+    # Step 3: Install nomic-embed-text model
+    def check_nomic_embed
+      label = "nomic-embed-text"
+      puts pastel.bold("\n3. #{label}")
+
+      unless command_exists?("ollama")
+        puts "  #{pastel.yellow("skipped")} ollama not available"
+        return [label, :skipped]
+      end
+
+      if model_installed?("nomic-embed-text")
+        puts "  #{pastel.green("found")} nomic-embed-text"
+        return [label, :exists]
+      end
+
+      # Auto-pull if ollama was just installed, otherwise prompt
+      unless @ollama_was_present == false || confirm?("Pull nomic-embed-text model?")
+        return [label, :skipped]
+      end
+
+      spinner = spin("Pulling nomic-embed-text")
+      if run_command("ollama pull nomic-embed-text")
+        spinner.success(pastel.green("done"))
+        [label, :installed]
+      else
+        spinner.error(pastel.red("failed"))
+        [label, :failed]
+      end
+    end
+
+    # Step 4a: Check for uv
+    def check_uv
+      label = "uv"
+      puts pastel.bold("\n4a. #{label}")
+
+      version = command_version("uv", "--version")
+      if version
+        puts "  #{pastel.green("found")} #{version}"
+        return [label, :exists]
+      end
+
+      install_cmd = brew_available? ? "brew install uv" : "curl -LsSf https://astral.sh/uv/install.sh | sh"
+
+      unless confirm?("uv not found. Install via `#{install_cmd}`?")
+        return [label, :skipped]
+      end
+
+      spinner = spin("Installing uv")
+      if run_command(install_cmd)
+        spinner.success(pastel.green("done"))
+        [label, :installed]
+      else
+        spinner.error(pastel.red("failed"))
+        [label, :failed]
+      end
+    end
+
+    # Step 4: Install piper-tts
+    def check_piper
+      label = "piper-tts"
+      puts pastel.bold("\n4b. #{label}")
+
+      version = command_version("piper", "--help")
+      if version
+        puts "  #{pastel.green("found")} piper"
+        return [label, :exists]
+      end
+
+      uv_bin = find_executable("uv")
+      unless uv_bin
+        puts "  #{pastel.yellow("skipped")} uv not available"
+        return [label, :skipped]
+      end
+
+      unless confirm?("piper-tts not found. Install via `uv tool install`?")
+        return [label, :skipped]
+      end
+
+      spinner = spin("Installing piper-tts")
+      if run_command("#{uv_bin} tool install piper-tts --with pathvalidate")
+        spinner.success(pastel.green("done"))
+        [label, :installed]
+      else
+        spinner.error(pastel.red("failed"))
+        [label, :failed]
+      end
+    end
+
+    # Helpers
+
+    def confirm?(message)
+      return true if auto_yes
+
+      print "  #{message} #{pastel.dim("[Y/n]")} "
+      response = $stdin.gets&.strip&.downcase
+      response.empty? || response == "y" || response == "yes"
+    end
+
+    def spin(message)
+      TTY::Spinner.new("  :spinner #{message}...", format: :dots)
+        .tap(&:auto_spin)
+    end
+
+    def command_exists?(cmd)
+      _, status = Open3.capture2e("which", cmd)
+      status.success?
+    end
+
+    def command_version(cmd, flag)
+      stdout, status = Open3.capture2e(cmd, flag)
+      status.success? ? stdout.strip.lines.first&.strip : nil
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def find_executable(cmd)
+      path, status = Open3.capture2e("which", cmd)
+      status.success? ? path.strip : nil
+    end
+
+    def run_command(cmd)
+      _, status = Open3.capture2e(cmd)
+      status.success?
+    end
+
+    def brew_available?
+      command_exists?("brew")
+    end
+
+    def model_installed?(name)
+      stdout, status = Open3.capture2e("ollama", "list")
+      return false unless status.success?
+
+      stdout.lines.any? { |line| line.include?(name) }
+    rescue Errno::ENOENT
+      false
+    end
+
+    def ensure_ollama_running
+      stdout, status = Open3.capture2e("ollama", "list")
+      return if status.success?
+
+      puts "  #{pastel.yellow("starting")} ollama serve"
+      spawn("ollama serve", [:out, :err] => "/dev/null")
+      sleep 2
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def print_result(label, status)
+      icon = case status
+      when :exists then pastel.green("[OK]")
+      when :installed then pastel.cyan("[INSTALLED]")
+      when :skipped then pastel.yellow("[SKIPPED]")
+      when :failed then pastel.red("[FAILED]")
+      end
+      puts "  #{icon} #{label}"
+    end
+  end
+end