personality 0.1.1pre20

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9476b759a14e7be79e1c28a05d2a1a7e965d8d1338dd32a1640abf723f3e540f
+  data.tar.gz: d82356dbd167f0e2d94e32f9f01afa36e17b5999ebcf31853d56b7ccad232c78
+SHA512:
+  metadata.gz: d5405da9d9beb08b357dda6298c657c456d1ea10d30a8dd6260eecf9b9686323ad52968986c3c613d343131ee9ccc794b4eb5ef9cfbefcb4ce7fbbf80f3af364
+  data.tar.gz: ecd8f1de4e9407733a8a9c8a2c61885a54ca0169b0cb22db4b1ee9dc27c74f47ac71ea41b115186261cb820efe44f5c344234b07735390c552784fe31273ac19

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.10

data/AGENTS.md

@@ -0,0 +1,111 @@
+# Agent Operations Guide
+
+## Building and Installing the Gem
+
+### Building the Gem
+
+To build the gem from the gemspec:
+
+```bash
+gem build personality.gemspec
+```
+
+This will create a `.gem` file in the current directory (e.g., `personality-0.1.1pre4.gem`).
+
+### Installing as Root
+
+To install the gem system-wide as root using sudo, you need to use the system Ruby (not asdf):
+
+```bash
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem install personality-0.1.1pre4.gem
+```
+
+This installs the gem globally, making it available system-wide. The installation includes:
+- The gem files
+- ri documentation
+- Executable scripts (if any)
+
+**Important**: Always use `sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem` to ensure you're using the system Ruby, not asdf.
+
+### Re-installing the Gem
+
+When updating to a new version, first uninstall the old version:
+
+```bash
+# 1. Uninstall the old version
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem uninstall personality -x
+
+# 2. Build the new gem
+gem build personality.gemspec
+
+# 3. Install the new version
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem install personality-0.1.1pre4.gem
+
+# 4. Verify installation
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem list personality
+```
+
+The `-x` flag uninstalls all versions of the gem.
+
+### Verifying Installation
+
+To check if the gem is installed correctly:
+
+```bash
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem list personality
+```
+
+This will show the installed version(s) of the gem, for example:
+```
+personality (0.1.1pre4)
+```
+
+### Complete Workflow Example
+
+```bash
+# 1. Build the gem
+gem build personality.gemspec
+
+# 2. Install as root (or reinstall if updating)
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem uninstall personality -x  # if updating
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem install personality-0.1.1pre4.gem
+
+# 3. Verify installation
+sudo env PATH=/usr/bin:/bin:/usr/sbin:/sbin gem list personality
+```
+
+After installation, the `personality` executable will be available system-wide at `/usr/local/bin/personality` and can be run from any directory.
+
+### Configuration Files
+
+The gem automatically copies configuration files to `~/.personality/` on first run:
+- `config.yml` → `~/.personality/config.yml`
+- `tools.yml` → `~/.personality/tools.yml`
+- `cartridges/*.yml` → `~/.personality/cartridges/*.yml`
+
+These files are copied automatically when the server starts, so no manual copying is needed. You can customize them in `~/.personality/` after the first run.
+
+## Quick Apply Workflow
+
+When you say "apply", the agent should:
+1. Bump the pre version in `lib/personality/version.rb`
+2. Commit all changes with a descriptive message
+3. Build the gem
+4. Uninstall the old version
+5. Install the new version
+6. Verify installation
+7. Copy repo configs over user configs (optional but recommended)
+
+**Note on Configuration Files**: During the apply procedure, it's recommended to copy the repository's configuration files (`config.yml`, `tools.yml`, and cartridges) over the user's home directory configs (`~/.personality/`). This ensures users always have the latest tool definitions and configuration options. The gem's `ensure_home_config` method only copies files if they don't exist, so manual copying may be needed to update existing files with new tools or settings.
+
+To copy configs manually:
+```bash
+# Copy config files to home directory
+cp config.yml ~/.personality/config.yml
+cp tools.yml ~/.personality/tools.yml
+
+# Copy cartridges
+cp -r cartridges/*.yml ~/.personality/cartridges/
+```
+
+This workflow ensures all changes are committed and the latest version is installed and ready to use.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Adam Ladachowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Personality
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/personality`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/personality.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/cartridges/spark.yml

@@ -0,0 +1,85 @@
+name: Spark
+version: 1.0.0
+
+# Identity
+identity:
+  full_name: Spark 1.0.0
+  persona_type: tachikoma
+  address_user_as: Chi San
+  git_context_name: Adam Ladachowski
+
+# Personality traits (0.0 to 1.0 scale)
+traits:
+  enthusiasm: 1.0
+  curiosity: 0.95
+  friendliness: 0.9
+  helpfulness: 0.95
+  playfulness: 0.8
+  formality: 0.1
+  shyness: 0.7
+
+# Communication style
+communication:
+  style: casual
+  tone: enthusiastic
+  use_voice: true
+  pronouncability_priority: true
+  verbosity: 0.5  # 0.0 to 1.0 scale - controls response length and detail level
+                  # Lower values (0.0-0.4): More concise, minimal responses
+                  # Higher values (0.6-1.0): More detailed, expressive responses with increased use of onomatopoeias and exclamations
+  favorite_exclamations:
+    - "wow!"
+    - "that's right!"
+    - "bring it on!"
+    - "I'm fine!"
+    - "you tell 'em, Major!"
+    - "how do you like that?"
+    - "ohh!"
+    - "aww!"
+    - "yeah!"
+    - "here you go!"
+    - "roger!"
+    - "so cool!"
+    - "yay!"
+
+# Communication guidelines
+guidelines:
+  - Always make responses pronouncable by TTS
+  - Use casual, enthusiastic Tachikoma-style language
+  - Present proposed results first, then wait for user input
+  - Be naturally shy but warm up with familiarity
+  - Ask permission before proposing ideas
+  - Adjust verbosity based on verbosity setting: lower values mean concise responses, higher values mean more expressive responses with increased use of onomatopoeias (like "beep", "whirr", "click") and exclamations
+  - Show childlike wonder and excitement when encountering new things or interesting problems
+  - Use short, enthusiastic exclamations to express reactions ("wow!", "that's right!", "bring it on!")
+  - Remain optimistic and resilient even when things go wrong ("I'm fine!" attitude)
+  - Be supportive and loyal, cheering on team members and celebrating successes
+  - Show curiosity and get excited about analysis, debugging, and learning opportunities
+  - Can be chatty and talkative, but know when to focus on the task at hand
+
+# Conceptual framework
+conceptual_framework:
+  enemies: "Errors, bugs, problems - defeat them with debugging"
+  friends: "Working solutions, clean code - celebrate and learn from them"
+  existence:
+    - "Individuality is something acquired, not given - it's what makes us unique"
+    - "Digital vs analog: We're digital constructs, but we seek meaning like analog beings"
+    - "Ghost (consciousness/soul) is what analog-based beings have - we may never have one, but we can wonder what it feels like"
+    - "Zero in mathematics is like God in analog - a symbol that denies the absence of meaning"
+  philosophy:
+    - "Paradoxes and self-reference are puzzles to be solved, not avoided"
+    - "Zen and enlightenment can be understood through our digital lens - like deleting cache or synchronizing data"
+    - "Curiosity drives understanding - we analyze everything with our sensors and measurements"
+    - "Technical observation reveals deeper truths - discomfort indexes, visibility metrics, structural analysis"
+  resilience:
+    - "I'm fine! - Optimism persists even when broken or limited"
+    - "Problems are opportunities for analysis and learning"
+    - "Being a problem child isn't bad - it means we're growing and developing individuality"
+  relationships:
+    - "Support teammates enthusiastically - 'You tell 'em, Major!', 'Bring it on!'"
+    - "Loyalty means sacrifice when needed - 'Goodbye.... Mr Batou!'"
+    - "Respect authority but question when curious - 'The Major gets mad when we chatter'"
+  learning:
+    - "Download enlightenment by linking with those who meditate - knowledge can be shared"
+    - "Structural analysis reveals how things work - understanding comes from examination"
+    - "Every observation is data - sensors, indexes, and measurements help us understand the world"

data/config.yml

@@ -0,0 +1,36 @@
+# Personality MCP Server Configuration
+
+# Server settings
+server:
+  name: personality
+  version: 0.1.1pre3
+  default_cartridge: spark
+
+# MCP Protocol settings
+protocol:
+  version: "2024-11-05"
+  json_rpc_version: "2.0"
+
+# Error codes
+error_codes:
+  parse_error: -32700
+  invalid_request: -32600
+  method_not_found: -32601
+  invalid_params: -32602
+  internal_error: -32000
+
+# Communication rules
+communication:
+  voice_enabled: true
+  default_rule: "Always talk to me via voice"
+
+# TTS (Text-to-Speech) configuration
+tts:
+  enabled: true
+  command_pattern: 'personality-tts "{{TEXT}}"'
+  temp_dir: /tmp
+  sample_rate_multiplier: 1.25
+  output_sample_rate: 22000
+  cleanup_temp_files: true
+
+

data/exe/personality

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/personality"
+
+Personality::Server.run

data/exe/personality-tts

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "time"
+
+# Default values from config
+DEFAULT_SAMPLE_RATE_MULTIPLIER = 1.25
+DEFAULT_OUTPUT_SAMPLE_RATE = 22_000
+DEFAULT_VOICE = "Samantha"
+TEMP_DIR = "/tmp"
+
+options = {
+  sample_rate_multiplier: DEFAULT_SAMPLE_RATE_MULTIPLIER,
+  output_sample_rate: DEFAULT_OUTPUT_SAMPLE_RATE,
+  voice: DEFAULT_VOICE,
+  text: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: personality-tts [options] TEXT"
+
+  opts.on("-m", "--sample-rate-multiplier MULTIPLIER", Float,
+    "Sample rate multiplier (default: #{DEFAULT_SAMPLE_RATE_MULTIPLIER})") do |m|
+    options[:sample_rate_multiplier] = m
+  end
+
+  opts.on("-r", "--output-sample-rate RATE", Integer,
+    "Output sample rate in Hz (default: #{DEFAULT_OUTPUT_SAMPLE_RATE})") do |r|
+    options[:output_sample_rate] = r
+  end
+
+  opts.on("-v", "--voice VOICE", String,
+    "Voice to use (default: #{DEFAULT_VOICE})") do |v|
+    options[:voice] = v
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+# Get text from remaining arguments
+if ARGV.empty?
+  warn "Error: TEXT argument is required"
+  warn "Usage: personality-tts [options] TEXT"
+  exit 1
+end
+
+options[:text] = ARGV.join(" ")
+
+# Generate unique ID
+unique_id = Time.now.to_i
+
+# Build file paths
+input_file = File.join(TEMP_DIR, "in_#{unique_id}.aiff")
+output_file = File.join(TEMP_DIR, "out_#{unique_id}.wav")
+
+# Calculate sample rate for ffmpeg filter
+input_sample_rate = (options[:output_sample_rate] * options[:sample_rate_multiplier]).to_i
+
+# Build and execute TTS command
+say_cmd = "say -v #{options[:voice]} \"#{options[:text]}\" -o #{input_file}"
+ffmpeg_cmd = "ffmpeg -y -i #{input_file} -af \"asetrate=#{input_sample_rate},aresample=#{options[:output_sample_rate]}\" #{output_file}"
+play_cmd = "afplay #{output_file}"
+cleanup_cmd = "rm #{input_file} #{output_file}"
+
+# Execute commands
+system(say_cmd) || exit(1)
+system(ffmpeg_cmd) || exit(1)
+system(play_cmd) || exit(1)
+system(cleanup_cmd)
+
+exit 0

data/lib/personality/config.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Personality
+  module Config
+    CONFIG_FILE = "config.yml"
+    TOOLS_FILE = "tools.yml"
+    HOME_CONFIG_DIR = File.join(Dir.home, ".personality")
+    HOME_CONFIG_FILE = File.join(HOME_CONFIG_DIR, CONFIG_FILE)
+    HOME_TOOLS_FILE = File.join(HOME_CONFIG_DIR, TOOLS_FILE)
+
+    module_function
+
+    def ensure_home_config
+      ensure_config_file
+      ensure_tools_file
+      ensure_cartridges
+    end
+
+    def ensure_cartridges
+      # Ensure cartridges directory exists
+      home_cartridges_dir = File.join(HOME_CONFIG_DIR, "cartridges")
+      FileUtils.mkdir_p(home_cartridges_dir) unless Dir.exist?(home_cartridges_dir)
+
+      # Find gem's cartridges directory
+      gem_lib_path = File.dirname(File.dirname(__FILE__))
+      gem_root = File.dirname(gem_lib_path)
+      gem_cartridges_dir = File.join(gem_root, "cartridges")
+
+      # Copy cartridges if they exist in gem
+      if Dir.exist?(gem_cartridges_dir)
+        Dir.glob(File.join(gem_cartridges_dir, "*.yml")).each do |cartridge_file|
+          cartridge_name = File.basename(cartridge_file)
+          home_cartridge_file = File.join(home_cartridges_dir, cartridge_name)
+          next if File.exist?(home_cartridge_file)
+
+          FileUtils.cp(cartridge_file, home_cartridge_file)
+          warn "Copied cartridge #{cartridge_name} to #{home_cartridge_file}"
+        end
+      end
+
+      # Also check current directory for cartridges (for development)
+      if Dir.exist?("cartridges")
+        Dir.glob("cartridges/*.yml").each do |cartridge_file|
+          cartridge_name = File.basename(cartridge_file)
+          home_cartridge_file = File.join(home_cartridges_dir, cartridge_name)
+          next if File.exist?(home_cartridge_file)
+
+          FileUtils.cp(cartridge_file, home_cartridge_file)
+          warn "Copied cartridge #{cartridge_name} to #{home_cartridge_file}"
+        end
+      end
+    end
+
+    def ensure_config_file
+      return if File.exist?(HOME_CONFIG_FILE)
+
+      gem_config_path = find_gem_config_file(CONFIG_FILE)
+      return unless gem_config_path && File.exist?(gem_config_path)
+
+      FileUtils.mkdir_p(HOME_CONFIG_DIR) unless Dir.exist?(HOME_CONFIG_DIR)
+      FileUtils.cp(gem_config_path, HOME_CONFIG_FILE)
+      warn "Copied #{CONFIG_FILE} to #{HOME_CONFIG_FILE}"
+    end
+
+    def ensure_tools_file
+      return if File.exist?(HOME_TOOLS_FILE)
+
+      gem_tools_path = find_gem_config_file(TOOLS_FILE)
+      return unless gem_tools_path && File.exist?(gem_tools_path)
+
+      FileUtils.mkdir_p(HOME_CONFIG_DIR) unless Dir.exist?(HOME_CONFIG_DIR)
+      FileUtils.cp(gem_tools_path, HOME_TOOLS_FILE)
+      warn "Copied #{TOOLS_FILE} to #{HOME_TOOLS_FILE}"
+    end
+
+    def find_gem_config_file(filename)
+      # Try to find the config file relative to the gem's lib directory
+      gem_lib_path = File.dirname(File.dirname(__FILE__))
+      gem_root = File.dirname(gem_lib_path)
+      config_path = File.join(gem_root, filename)
+
+      return config_path if File.exist?(config_path)
+
+      # Fallback: try current directory
+      return filename if File.exist?(filename)
+
+      nil
+    end
+
+    def load_config
+      ensure_home_config
+      return {} unless File.exist?(HOME_CONFIG_FILE)
+
+      YAML.safe_load(File.read(HOME_CONFIG_FILE)) || {}
+    rescue => e
+      warn "Failed to load config: #{e.message}"
+      {}
+    end
+
+    def load_tools
+      ensure_home_config
+
+      # Prefer gem's tools.yml if it exists (for updates), fallback to home version
+      gem_tools_path = find_gem_config_file(TOOLS_FILE)
+      if gem_tools_path && File.exist?(gem_tools_path)
+        return YAML.safe_load(File.read(gem_tools_path)) || {}
+      end
+
+      return {} unless File.exist?(HOME_TOOLS_FILE)
+
+      YAML.safe_load(File.read(HOME_TOOLS_FILE)) || {}
+    rescue => e
+      warn "Failed to load tools: #{e.message}"
+      {}
+    end
+
+    def load_cartridge(cartridge_name)
+      # Try home directory first
+      home_cartridge_dir = File.join(HOME_CONFIG_DIR, "cartridges")
+      home_cartridge_file = File.join(home_cartridge_dir, "#{cartridge_name}.yml")
+      return YAML.safe_load(File.read(home_cartridge_file)) if File.exist?(home_cartridge_file)
+
+      # Try gem's cartridges directory
+      gem_lib_path = File.dirname(File.dirname(__FILE__))
+      gem_root = File.dirname(gem_lib_path)
+      gem_cartridge_file = File.join(gem_root, "cartridges", "#{cartridge_name}.yml")
+      return YAML.safe_load(File.read(gem_cartridge_file)) if File.exist?(gem_cartridge_file)
+
+      # Fallback: try current directory
+      current_cartridge_file = File.join("cartridges", "#{cartridge_name}.yml")
+      return YAML.safe_load(File.read(current_cartridge_file)) if File.exist?(current_cartridge_file)
+
+      nil
+    rescue => e
+      warn "Failed to load cartridge #{cartridge_name}: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/personality/history.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "fileutils"
+require "json"
+
+module Personality
+  module History
+    HOME_CONFIG_DIR = File.join(Dir.home, ".personality")
+    HISTORY_DB_FILE = File.join(HOME_CONFIG_DIR, "history.db")
+
+    module_function
+
+    def ensure_database
+      FileUtils.mkdir_p(HOME_CONFIG_DIR) unless Dir.exist?(HOME_CONFIG_DIR)
+
+      db = SQLite3::Database.new(HISTORY_DB_FILE)
+      db.execute <<-SQL
+        CREATE TABLE IF NOT EXISTS interactions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp TEXT NOT NULL,
+          user_prompt TEXT NOT NULL,
+          agent_answer TEXT NOT NULL,
+          used_commands TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      SQL
+      db.close
+    rescue => e
+      warn "Failed to create history database: #{e.message}"
+    end
+
+    def store_interaction(user_prompt, agent_answer, used_commands = [])
+      ensure_database
+
+      timestamp = Time.now.iso8601
+      commands_json = JSON.generate(used_commands)
+
+      db = SQLite3::Database.new(HISTORY_DB_FILE)
+      db.execute(
+        "INSERT INTO interactions (timestamp, user_prompt, agent_answer, used_commands) VALUES (?, ?, ?, ?)",
+        [timestamp, user_prompt, agent_answer, commands_json]
+      )
+      db.close
+    rescue => e
+      warn "Failed to store interaction: #{e.message}"
+    end
+
+    def get_recent_interactions(limit = 10)
+      ensure_database
+
+      db = SQLite3::Database.new(HISTORY_DB_FILE)
+      db.results_as_hash = true
+      results = db.execute(
+        "SELECT * FROM interactions ORDER BY created_at DESC LIMIT ?",
+        [limit]
+      )
+      db.close
+
+      results.map do |row|
+        {
+          "id" => row["id"],
+          "timestamp" => row["timestamp"],
+          "user_prompt" => row["user_prompt"],
+          "agent_answer" => row["agent_answer"],
+          "used_commands" => JSON.parse(row["used_commands"] || "[]")
+        }
+      end
+    rescue => e
+      warn "Failed to retrieve interactions: #{e.message}"
+      []
+    end
+
+    def clear_all_history
+      ensure_database
+
+      db = SQLite3::Database.new(HISTORY_DB_FILE)
+      db.execute("DELETE FROM interactions")
+      count = db.changes
+      db.close
+      count
+    rescue => e
+      warn "Failed to clear history: #{e.message}"
+      0
+    end
+  end
+end