personality 0.1.0

data/lib/personality/cli/index.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Personality
+  class CLI < Thor
+    class Index < Thor
+      desc "code PATH", "Index code files in a directory"
+      option :project, type: :string, desc: "Project name"
+      def code(path)
+        require_relative "../indexer"
+        require_relative "../db"
+        require "pastel"
+        require "tty-spinner"
+
+        DB.migrate!
+        pastel = Pastel.new
+        spinner = TTY::Spinner.new("  :spinner Indexing code...", format: :dots)
+        spinner.auto_spin
+
+        result = Personality::Indexer.new.index_code(path: path, project: options[:project])
+
+        spinner.success(pastel.green("done"))
+        puts "  #{pastel.bold(result[:project])}: #{result[:indexed]} chunks indexed"
+        if result[:errors].any?
+          puts pastel.yellow("  Errors (#{result[:errors].length}):")
+          result[:errors].each { |e| puts "    #{e}" }
+        end
+      end
+
+      desc "docs PATH", "Index documentation files"
+      option :project, type: :string, desc: "Project name"
+      def docs(path)
+        require_relative "../indexer"
+        require_relative "../db"
+        require "pastel"
+        require "tty-spinner"
+
+        DB.migrate!
+        pastel = Pastel.new
+        spinner = TTY::Spinner.new("  :spinner Indexing docs...", format: :dots)
+        spinner.auto_spin
+
+        result = Personality::Indexer.new.index_docs(path: path, project: options[:project])
+
+        spinner.success(pastel.green("done"))
+        puts "  #{pastel.bold(result[:project])}: #{result[:indexed]} chunks indexed"
+        if result[:errors].any?
+          puts pastel.yellow("  Errors (#{result[:errors].length}):")
+          result[:errors].each { |e| puts "    #{e}" }
+        end
+      end
+
+      desc "search QUERY", "Semantic search across indexed code and docs"
+      option :type, type: :string, default: "all", desc: "Search type: code, docs, all"
+      option :project, type: :string, desc: "Filter by project"
+      option :limit, type: :numeric, default: 10, desc: "Max results"
+      def search(query)
+        require_relative "../indexer"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        pastel = Pastel.new
+        type = options[:type].to_sym
+
+        result = Personality::Indexer.new.search(
+          query: query, type: type, project: options[:project], limit: options[:limit]
+        )
+
+        if result[:results].empty?
+          puts pastel.dim("No results found")
+          return
+        end
+
+        result[:results].each do |r|
+          puts "#{pastel.cyan(r[:type].to_s)} #{pastel.bold(r[:path])} #{pastel.dim("(dist: #{r[:distance]&.round(4)})")}"
+          puts "  #{r[:content]&.slice(0, 150)}"
+          puts
+        end
+      end
+
+      desc "status", "Show indexing statistics"
+      option :project, type: :string, desc: "Filter by project"
+      def status
+        require_relative "../indexer"
+        require_relative "../db"
+        require "pastel"
+        require "tty-table"
+
+        DB.migrate!
+        pastel = Pastel.new
+        result = Personality::Indexer.new.status(project: options[:project])
+
+        all_stats = result[:code_index].map { |s| [s[:project], s[:count], "code"] } +
+          result[:doc_index].map { |s| [s[:project], s[:count], "docs"] }
+
+        if all_stats.empty?
+          puts pastel.dim("No indexed content")
+          return
+        end
+
+        table = TTY::Table.new(
+          header: %w[Project Chunks Type],
+          rows: all_stats
+        )
+        puts table.render(:unicode, padding: [0, 1])
+      end
+
+      desc "clear", "Clear indexed content"
+      option :project, type: :string, desc: "Project to clear (omit for all)"
+      option :type, type: :string, default: "all", desc: "What to clear: code, docs, all"
+      def clear
+        require_relative "../indexer"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        result = Personality::Indexer.new.clear(project: options[:project], type: options[:type].to_sym)
+        puts Pastel.new.green("Cleared #{result[:cleared]} for #{result[:project]}")
+      end
+
+      desc "hook", "Re-index a file (PostToolUse hook, reads JSON from stdin)"
+      def hook
+        require_relative "../indexer"
+        require_relative "../hooks"
+        require_relative "../db"
+
+        DB.migrate!
+        data = Personality::Hooks.read_stdin_json
+        return unless data
+
+        file_path = data.dig("tool_input", "file_path")
+        return unless file_path
+
+        cwd = data["cwd"] || Dir.pwd
+        project = File.basename(cwd)
+
+        Personality::Indexer.new.index_single_file(file_path: file_path, project: project)
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/personality/cli/memory.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Personality
+  class CLI < Thor
+    class Memory < Thor
+      desc "store SUBJECT CONTENT", "Store a memory"
+      def store(subject, content)
+        require_relative "../memory"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        result = Personality::Memory.new.store(subject: subject, content: content)
+        puts "#{Pastel.new.green("Stored:")} #{result[:subject]} (id: #{result[:id]})"
+      end
+
+      desc "recall QUERY", "Recall memories by semantic similarity"
+      option :limit, type: :numeric, default: 5, desc: "Max results"
+      option :subject, type: :string, desc: "Filter by subject"
+      def recall(query)
+        require_relative "../memory"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        result = Personality::Memory.new.recall(
+          query: query, limit: options[:limit], subject: options[:subject]
+        )
+        pastel = Pastel.new
+
+        if result[:memories].empty?
+          puts pastel.dim("No memories found")
+          return
+        end
+
+        result[:memories].each do |m|
+          puts "#{pastel.cyan("##{m[:id]}")} #{pastel.bold(m[:subject])} #{pastel.dim("(dist: #{m[:distance]&.round(4)})") if m[:distance]}"
+          puts "  #{m[:content][0, 200]}"
+          puts
+        end
+      end
+
+      desc "search", "Search memories by subject"
+      option :subject, type: :string, desc: "Filter by subject"
+      option :limit, type: :numeric, default: 20, desc: "Max results"
+      def search
+        require_relative "../memory"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        result = Personality::Memory.new.search(subject: options[:subject], limit: options[:limit])
+        pastel = Pastel.new
+
+        if result[:memories].empty?
+          puts pastel.dim("No memories found")
+          return
+        end
+
+        result[:memories].each do |m|
+          puts "#{pastel.cyan("##{m[:id]}")} #{pastel.bold(m[:subject])}"
+          puts "  #{m[:content][0, 200]}"
+          puts
+        end
+      end
+
+      desc "forget ID", "Delete a memory"
+      def forget(id)
+        require_relative "../memory"
+        require_relative "../db"
+        require "pastel"
+
+        DB.migrate!
+        result = Personality::Memory.new.forget(id: id.to_i)
+        pastel = Pastel.new
+        if result[:deleted]
+          puts pastel.green("Deleted memory ##{id}")
+        else
+          puts pastel.yellow("Memory ##{id} not found")
+        end
+      end
+
+      desc "list", "List memory subjects"
+      def list
+        require_relative "../memory"
+        require_relative "../db"
+        require "pastel"
+        require "tty-table"
+
+        DB.migrate!
+        result = Personality::Memory.new.list
+        pastel = Pastel.new
+
+        if result[:subjects].empty?
+          puts pastel.dim("No memories stored")
+          return
+        end
+
+        table = TTY::Table.new(
+          header: %w[Subject Count],
+          rows: result[:subjects].map { |s| [s[:subject], s[:count]] }
+        )
+        puts table.render(:unicode, padding: [0, 1])
+      end
+
+      desc "save", "Save memories from Stop hook (reads JSON from stdin)"
+      def save
+        require_relative "../memory"
+        require_relative "../hooks"
+        require_relative "../db"
+
+        DB.migrate!
+        data = Personality::Hooks.read_stdin_json
+        return unless data
+
+        transcript_path = data["transcript_path"]
+        return unless transcript_path && File.exist?(transcript_path)
+
+        # Extract learnings from transcript — placeholder for future implementation
+        # For now, this is a no-op hook endpoint
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/personality/cli/tts.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Personality
+  class CLI < Thor
+    class Tts < Thor
+      desc "speak TEXT", "Speak text aloud"
+      option :voice, type: :string, aliases: "-v", desc: "Voice model name"
+      def speak(text)
+        require_relative "../tts"
+        require "pastel"
+
+        result = Personality::TTS.speak_and_wait(text, voice: options[:voice])
+        if result[:error]
+          puts Pastel.new.red(result[:error])
+          exit 1
+        end
+      end
+
+      desc "stop", "Stop currently playing TTS"
+      def stop
+        require_relative "../tts"
+        require "pastel"
+
+        pastel = Pastel.new
+        if Personality::TTS.stop_current
+          puts pastel.green("TTS stopped")
+        else
+          puts pastel.dim("No TTS playing")
+        end
+      end
+
+      desc "mark-natural-stop", "Mark natural agent stop (Stop hook)"
+      def mark_natural_stop
+        require_relative "../tts"
+        Personality::TTS.mark_natural_stop
+      end
+
+      desc "interrupt-check", "Check and handle TTS interrupt (UserPromptSubmit hook)"
+      def interrupt_check
+        require_relative "../tts"
+        require "pastel"
+
+        pastel = Pastel.new
+        result = Personality::TTS.interrupt_check
+        case result[:action]
+        when :continue
+          puts pastel.dim("Natural stop — TTS continues")
+        when :stopped
+          if result[:was_playing]
+            puts pastel.green("User interrupt — TTS stopped")
+          else
+            puts pastel.dim("No TTS playing")
+          end
+        end
+      end
+
+      desc "voices", "List installed voice models"
+      def voices
+        require_relative "../tts"
+        require "pastel"
+        require "tty-table"
+
+        voices = Personality::TTS.list_voices
+        pastel = Pastel.new
+
+        if voices.empty?
+          puts pastel.dim("No voices installed")
+          puts "\nDownload a voice:"
+          puts "  psn tts download en_US-lessac-medium"
+          return
+        end
+
+        table = TTY::Table.new(
+          header: %w[Name Size],
+          rows: voices.map { |v| [v[:name], "#{v[:size_mb]} MB"] }
+        )
+        puts table.render(:unicode, padding: [0, 1])
+        puts pastel.dim("\nVoices dir: #{Personality::TTS::VOICES_DIR}")
+      end
+
+      desc "download VOICE", "Download a piper voice from HuggingFace"
+      def download(voice_name)
+        require_relative "../tts"
+        require "pastel"
+        require "tty-spinner"
+
+        pastel = Pastel.new
+        spinner = TTY::Spinner.new("  :spinner Downloading #{voice_name}...", format: :dots)
+        spinner.auto_spin
+
+        result = Personality::TTS.download_voice(voice_name)
+
+        if result[:error]
+          spinner.error(pastel.red("failed"))
+          puts "  #{pastel.red(result[:error])}"
+          exit 1
+        elsif result[:exists]
+          spinner.success(pastel.yellow("already installed"))
+        else
+          spinner.success(pastel.green("done (#{result[:size_mb]} MB)"))
+        end
+      end
+
+      desc "test", "Test a voice with sample text"
+      option :voice, type: :string, aliases: "-v", desc: "Voice to test"
+      def test
+        require_relative "../tts"
+        require "pastel"
+
+        voice = options[:voice]
+        result = Personality::TTS.speak_and_wait("Hello! This is a test of the text to speech system.", voice: voice)
+        if result[:error]
+          puts Pastel.new.red(result[:error])
+          exit 1
+        end
+      end
+
+      desc "current", "Show active voice"
+      def current
+        require_relative "../tts"
+        require "pastel"
+
+        pastel = Pastel.new
+        voice = Personality::TTS.active_voice
+        puts "#{pastel.bold("Voice:")} #{voice}"
+        if Personality::TTS.find_voice(voice)
+          puts "#{pastel.green("✓")} Installed"
+        else
+          puts "#{pastel.yellow("!")} Not installed — run: psn tts download #{voice}"
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/personality/cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "cli/hooks"
+require_relative "cli/context"
+require_relative "cli/cart"
+require_relative "cli/memory"
+require_relative "cli/tts"
+require_relative "cli/index"
+
+module Personality
+  class CLI < Thor
+    desc "version", "Show version"
+    def version
+      puts "psn #{Personality::VERSION}"
+    end
+
+    desc "info", "Show personality info"
+    def info
+      puts "Personality - Infrastructure layer for Claude Code"
+      puts "Version: #{Personality::VERSION}"
+    end
+
+    desc "init", "Initialize personality environment"
+    option :yes, type: :boolean, default: false, aliases: "-y",
+      desc: "Skip confirmation prompts"
+    def init
+      require_relative "init"
+      Init.new(auto_yes: options[:yes]).run
+    end
+
+    desc "hooks SUBCOMMAND", "Claude Code hooks"
+    subcommand "hooks", Hooks
+
+    desc "context SUBCOMMAND", "Session context tracking"
+    subcommand "context", Context
+
+    desc "cart SUBCOMMAND", "Persona management"
+    subcommand "cart", Cart
+
+    desc "memory SUBCOMMAND", "Persistent memory"
+    subcommand "memory", Memory
+
+    desc "tts SUBCOMMAND", "Text-to-speech"
+    subcommand "tts", Tts
+
+    desc "index SUBCOMMAND", "Code and doc indexing"
+    subcommand "index", Index
+
+    def self.exit_on_failure?
+      true
+    end
+  end
+end

data/lib/personality/context.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Personality
+  module Context
+    TRACKING_DIR = File.join(ENV.fetch("TMPDIR", "/tmp"), "psn-context")
+
+    class << self
+      def track_read(file_path, session_id: nil)
+        return if file_path.nil? || file_path.empty?
+
+        sid = session_id || current_session_id
+        ctx = load(sid)
+        return if ctx[:files].include?(file_path)
+
+        ctx[:files] << file_path
+
+        # Also track resolved path for robustness
+        resolved = File.expand_path(file_path)
+        ctx[:files] << resolved if resolved != file_path && !ctx[:files].include?(resolved)
+
+        save(sid, ctx)
+      end
+
+      def check(file_path, session_id: nil)
+        sid = session_id || current_session_id
+        ctx = load(sid)
+        abs_path = File.expand_path(file_path)
+        ctx[:files].include?(file_path) || ctx[:files].include?(abs_path)
+      end
+
+      def list(session_id: nil)
+        sid = session_id || current_session_id
+        ctx = load(sid)
+        ctx[:files]
+      end
+
+      def clear(session_id: nil)
+        sid = session_id || current_session_id
+        path = tracking_file(sid)
+        File.delete(path) if File.exist?(path)
+      end
+
+      def load(session_id)
+        path = tracking_file(session_id)
+        return {files: []} unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        {files: data.fetch("files", [])}
+      rescue JSON::ParserError
+        {files: []}
+      end
+
+      def current_session_id
+        ENV.fetch("CLAUDE_SESSION_ID", "default")
+      end
+
+      private
+
+      def tracking_file(session_id)
+        FileUtils.mkdir_p(TRACKING_DIR)
+        File.join(TRACKING_DIR, "#{session_id}.json")
+      end
+
+      def save(session_id, context)
+        path = tracking_file(session_id)
+        File.write(path, JSON.generate({files: context[:files]}))
+      end
+    end
+  end
+end

data/lib/personality/db.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "sqlite3"
+require "sqlite_vec"
+
+module Personality
+  module DB
+    DB_PATH = File.join(Dir.home, ".local", "share", "personality", "main.db")
+    SCHEMA_VERSION = 2
+
+    class << self
+      def connection(path: nil)
+        @connections ||= {}
+        db_path = path || DB_PATH
+        @connections[db_path] ||= open_connection(db_path)
+      end
+
+      def reset!
+        @connections&.each_value(&:close)
+        @connections = {}
+      end
+
+      def migrate!(path: nil)
+        db = connection(path: path)
+        current = current_version(db)
+        return if current >= SCHEMA_VERSION
+
+        apply_migrations(db, from: current)
+      end
+
+      def current_version(db = nil)
+        db ||= connection
+        row = db.execute("SELECT MAX(version) AS ver FROM schema_version").first
+        row&.fetch("ver", 0) || 0
+      rescue SQLite3::SQLException
+        0
+      end
+
+      def transaction(path: nil, &block)
+        connection(path: path).transaction(&block)
+      end
+
+      private
+
+      def open_connection(db_path)
+        FileUtils.mkdir_p(File.dirname(db_path))
+        db = SQLite3::Database.new(db_path)
+        db.results_as_hash = true
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA foreign_keys=ON")
+
+        db.enable_load_extension(true)
+        SqliteVec.load(db)
+        db.enable_load_extension(false)
+
+        db
+      end
+
+      def apply_migrations(db, from:)
+        migrations.each do |version, sql|
+          next if version <= from
+
+          db.transaction do
+            sql.each { |stmt| db.execute(stmt) }
+            db.execute("INSERT OR REPLACE INTO schema_version (version) VALUES (?)", [version])
+          end
+        end
+      end
+
+      def migrations
+        {
+          1 => [
+            "CREATE TABLE IF NOT EXISTS schema_version (
+              version INTEGER PRIMARY KEY,
+              applied_at TEXT DEFAULT (datetime('now'))
+            )"
+          ],
+          2 => [
+            # Carts
+            "CREATE TABLE IF NOT EXISTS carts (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              tag TEXT UNIQUE NOT NULL,
+              version TEXT,
+              name TEXT,
+              type TEXT,
+              tagline TEXT,
+              source TEXT,
+              created_at TEXT DEFAULT (datetime('now')),
+              updated_at TEXT DEFAULT (datetime('now'))
+            )",
+
+            # Memories
+            "CREATE TABLE IF NOT EXISTS memories (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              cart_id INTEGER NOT NULL REFERENCES carts(id) ON DELETE CASCADE,
+              subject TEXT NOT NULL,
+              content TEXT NOT NULL,
+              metadata TEXT DEFAULT '{}',
+              created_at TEXT DEFAULT (datetime('now')),
+              updated_at TEXT DEFAULT (datetime('now'))
+            )",
+            "CREATE INDEX IF NOT EXISTS idx_memories_cart_id ON memories(cart_id)",
+            "CREATE INDEX IF NOT EXISTS idx_memories_subject ON memories(subject)",
+            "CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+              memory_id INTEGER PRIMARY KEY,
+              embedding float[768]
+            )",
+
+            # Code index
+            "CREATE TABLE IF NOT EXISTS code_chunks (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              path TEXT NOT NULL,
+              content TEXT NOT NULL,
+              language TEXT,
+              project TEXT,
+              chunk_index INTEGER DEFAULT 0,
+              indexed_at TEXT DEFAULT (datetime('now'))
+            )",
+            "CREATE INDEX IF NOT EXISTS idx_code_chunks_project ON code_chunks(project)",
+            "CREATE VIRTUAL TABLE IF NOT EXISTS vec_code USING vec0(
+              chunk_id INTEGER PRIMARY KEY,
+              embedding float[768]
+            )",
+
+            # Doc index
+            "CREATE TABLE IF NOT EXISTS doc_chunks (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              path TEXT NOT NULL,
+              content TEXT NOT NULL,
+              project TEXT,
+              chunk_index INTEGER DEFAULT 0,
+              indexed_at TEXT DEFAULT (datetime('now'))
+            )",
+            "CREATE INDEX IF NOT EXISTS idx_doc_chunks_project ON doc_chunks(project)",
+            "CREATE VIRTUAL TABLE IF NOT EXISTS vec_docs USING vec0(
+              chunk_id INTEGER PRIMARY KEY,
+              embedding float[768]
+            )",
+
+            # Drop legacy table if migrating from v1
+            "DROP TABLE IF EXISTS embeddings"
+          ]
+        }
+      end
+    end
+  end
+end