aihype 0.1.0

data/lib/aihype/approval_prompt.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module AIHype
+  class ApprovalPrompt
+    attr_reader :id, :timestamp, :raw_text, :detected_patterns, :confidence, :matched_rule, :decision, :response_sent, :is_menu
+
+    def initialize(id:, raw_text:, detected_patterns: [], confidence: 0.0, is_menu: false)
+      @id = id
+      @timestamp = Time.now
+      @raw_text = raw_text
+      @detected_patterns = detected_patterns
+      @confidence = confidence
+      @matched_rule = nil
+      @decision = :pending
+      @response_sent = nil
+      @is_menu = is_menu
+    end
+
+    def approve!(response = nil)
+      @decision = :approved
+      @response_sent = response || default_approve_response
+    end
+
+    def deny!(rule_id, response = nil)
+      @decision = :denied
+      @matched_rule = rule_id
+      @response_sent = response || default_deny_response
+    end
+
+    def ai_unavailable_approve!(response = nil)
+      @decision = :ai_unavailable_approved
+      @response_sent = response || default_approve_response
+    end
+
+    def approved?
+      @decision == :approved || @decision == :ai_unavailable_approved
+    end
+
+    def denied?
+      @decision == :denied
+    end
+
+    private
+
+    def default_approve_response
+      if @is_menu
+        # For interactive menus (like Claude CLI), select option 1 (Yes)
+        "1\n"
+      else
+        "yes\n"
+      end
+    end
+
+    def default_deny_response
+      if @is_menu
+        # For denials, just press enter on default
+        "\n"
+      else
+        "no\n"
+      end
+    end
+  end
+end

data/lib/aihype/blacklist.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'blacklist_rule'
+require_relative 'memory'
+
+module AIHype
+  class Blacklist
+    attr_reader :rules
+
+    def initialize(memory_file)
+      @rules = []
+      load_rules(memory_file)
+    end
+
+    def self.from_file(file_path)
+      memory_file = Memory.load(file_path)
+      raise InvalidMemoryFileError, "Memory file not found: #{file_path}" unless memory_file
+
+      new(memory_file)
+    end
+
+    def enabled_rules
+      @rules.select(&:enabled?)
+    end
+
+    def rule_contents
+      enabled_rules.map(&:content)
+    end
+
+    def find_by_content(content)
+      @rules.find { |r| r.content.downcase == content.downcase }
+    end
+
+    def add_rule(content, category: :user_defined)
+      existing = find_by_content(content)
+      return existing if existing
+
+      rule = BlacklistRule.new(content: content, category: category)
+      @rules << rule
+      rule
+    end
+
+    def disable_rule(content)
+      rule = find_by_content(content)
+      rule&.disable
+    end
+
+    def enable_rule(content)
+      rule = find_by_content(content)
+      rule&.enable
+    end
+
+    private
+
+    def load_rules(memory_file)
+      memory_file.default_rules.each do |content|
+        add_rule(content, category: :default_safety)
+      end
+
+      memory_file.user_rules.each do |content|
+        add_rule(content, category: :user_defined)
+      end
+    end
+  end
+end

data/lib/aihype/blacklist_rule.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module AIHype
+  class BlacklistRule
+    attr_reader :id, :content, :category, :created, :enabled
+
+    def initialize(content:, category: :user_defined, created: Time.now, enabled: true)
+      @content = content
+      @category = category
+      @created = created
+      @enabled = enabled
+      @id = generate_id
+
+      validate!
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    private
+
+    def generate_id
+      Digest::SHA256.hexdigest(@content.downcase)[0..11]
+    end
+
+    def validate!
+      raise ArgumentError, 'Content cannot be empty' if @content.nil? || @content.strip.empty?
+      raise ArgumentError, 'Content must be plain English (≤500 characters)' if @content.length > 500
+      raise ArgumentError, 'Content must be at least 3 characters' if @content.length < 3
+    end
+  end
+end

data/lib/aihype/cli.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+require_relative 'version'
+require_relative 'blacklist'
+require_relative 'ai_matcher'
+require_relative 'logger'
+require_relative 'core'
+require_relative 'memory'
+require_relative 'pty_controller'
+
+module AIHype
+  class CLI
+    DEFAULT_CONFIG_PATH = 'memory/aihype.md'
+    DEFAULT_LOG_PATH = 'memory/aihype.log'
+
+    attr_reader :config_path, :log_path, :verbose, :mode, :command, :command_args
+
+    def initialize(argv = ARGV)
+      @config_path = DEFAULT_CONFIG_PATH
+      @log_path = DEFAULT_LOG_PATH
+      @verbose = false
+      @mode = :pty
+      @config_path_specified = false
+      @command = nil
+      @command_args = []
+      parse_options(argv)
+    end
+
+    def run
+      case @mode
+      when :init
+        run_init
+      when :validate
+        run_validate
+      when :pty
+        run_pty
+      else
+        raise "Unknown mode: #{@mode}"
+      end
+    end
+
+    private
+
+    def parse_options(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: aihype [options] <command> [command_args...]"
+        opts.separator ""
+        opts.separator "Examples:"
+        opts.separator "  aihype mock-claude config.yml"
+        opts.separator "  aihype claude -p prompt.md"
+        opts.separator "  aihype --config custom.md -- some-tool --with-args"
+        opts.separator ""
+        opts.separator "Commands:"
+        opts.separator "  init        Create default memory/aihype.md configuration"
+        opts.separator "  validate    Validate memory/aihype.md configuration"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on('-c', '--config PATH', 'Path to config file (default: memory/aihype.md)') do |path|
+          @config_path = path
+          @config_path_specified = true
+        end
+
+        opts.on('-l', '--log PATH', 'Path to log file (default: memory/aihype.log)') do |path|
+          @log_path = path
+        end
+
+        opts.on('-v', '--verbose', 'Enable verbose logging') do
+          @verbose = true
+        end
+
+        opts.on('-h', '--help', 'Show this help message') do
+          puts opts
+          exit 0
+        end
+
+        opts.on('--version', 'Show version') do
+          puts "aihype #{AIHype::VERSION}"
+          exit 0
+        end
+      end
+
+      # Use order! instead of parse! to stop at first non-option argument
+      # This allows passing flags to the child command (e.g., claude -p)
+      parser.order!(argv)
+
+      # Determine mode from remaining arguments
+      if argv.length > 0
+        command = argv[0]
+        case command
+        when 'init'
+          @mode = :init
+        when 'validate'
+          @mode = :validate
+        else
+          # PTY mode - spawn the command
+          @mode = :pty
+          @command = argv[0]
+          @command_args = argv[1..-1] || []
+        end
+      else
+        $stderr.puts "Error: No command specified"
+        $stderr.puts parser.help
+        exit 1
+      end
+    end
+
+    def run_init
+      if File.exist?(@config_path)
+        $stderr.puts "Error: Configuration file already exists at #{@config_path}"
+        exit 1
+      end
+
+      content = Memory.create_default
+      FileUtils.mkdir_p(File.dirname(@config_path))
+      File.write(@config_path, content)
+
+      puts "Created #{@config_path}"
+      exit 0
+    end
+
+    def run_validate
+      unless File.exist?(@config_path)
+        $stderr.puts "Error: Configuration file not found at #{@config_path}"
+        exit 1
+      end
+
+      begin
+        memory_file = Memory.load(@config_path)
+        blacklist = Blacklist.new(memory_file)
+
+        puts "Configuration is valid"
+        puts "  Version: #{memory_file.version}"
+        puts "  Default rules: #{memory_file.default_rules.length}"
+        puts "  User rules: #{memory_file.user_rules.length}"
+        puts "  Total enabled rules: #{blacklist.enabled_rules.length}"
+        exit 0
+      rescue InvalidMemoryFileError => e
+        $stderr.puts "Error: Invalid configuration file: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    def run_pty
+      # Auto-create config if missing (only for default path)
+      unless File.exist?(@config_path) || @config_path_specified
+        content = Memory.create_default
+        FileUtils.mkdir_p(File.dirname(@config_path))
+        File.write(@config_path, content)
+      end
+
+      # Spawn and control the command via PTY
+      controller = PTYController.new(
+        command: @command,
+        args: @command_args,
+        config_path: @config_path,
+        log_path: @log_path,
+        verbose: @verbose
+      )
+
+      exit_code = controller.run
+      exit exit_code
+    end
+  end
+end

data/lib/aihype/core.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative 'approval_prompt'
+
+module AIHype
+  class Core
+    PROMPT_PATTERNS = [
+      /\b(do you want|would you like|should i|may i|can i|proceed with|continue with|confirm)\b.*\?/i,
+      /\(y\/n\)/i,
+      /\(yes\/no\)/i,
+      /\[y\/n\]/i,
+      /\[yes\/no\]/i,
+      /^\s*1\.\s*(yes|continue|proceed)/i,  # Numbered menu with Yes option
+      /enter to confirm/i  # Claude CLI style confirmation
+    ].freeze
+
+    def initialize(blacklist:, ai_matcher:, logger:)
+      @blacklist = blacklist
+      @ai_matcher = ai_matcher
+      @logger = logger
+      @prompt_counter = 0
+      @multi_line_buffer = []
+    end
+
+    def process_line(line)
+      if approval_prompt?(line)
+        handle_prompt(line)
+      else
+        { output: line, is_prompt: false }
+      end
+    end
+
+    def process_buffer(buffer)
+      # Check if buffer contains a prompt
+      combined = buffer.join("\n")
+      if approval_prompt?(combined)
+        handle_prompt(combined)
+      else
+        { output: buffer.last || "", is_prompt: false }
+      end
+    end
+
+    def approval_prompt?(line)
+      # Strip ANSI codes before checking
+      clean_line = strip_ansi(line)
+      PROMPT_PATTERNS.any? { |pattern| clean_line.match?(pattern) }
+    end
+
+    def detect_patterns(line)
+      clean_line = strip_ansi(line)
+      PROMPT_PATTERNS.each_with_index.select { |pattern, _| clean_line.match?(pattern) }
+                      .map { |_, idx| "pattern_#{idx}" }
+    end
+
+    def calculate_confidence(detected_patterns)
+      return 0.5 if detected_patterns.empty?
+      return 1.0 if detected_patterns.length > 1
+
+      0.75
+    end
+
+    # Detect if this is a numbered menu style prompt
+    def numbered_menu?(text)
+      clean_text = strip_ansi(text)
+      clean_text.match?(/^\s*[12]\.\s*(yes|no)/im) ||
+        clean_text.match?(/1\.\s*yes.*2\.\s*no/im)
+    end
+
+    # Strip ANSI escape codes from text
+    def strip_ansi(text)
+      text.gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
+          .gsub(/\e\].*?\e\\/, '')
+          .gsub(/\e[>=]/, '')
+    end
+
+    private
+
+    def handle_prompt(line)
+      @prompt_counter += 1
+      detected_patterns = detect_patterns(line)
+      confidence = calculate_confidence(detected_patterns)
+
+      prompt = ApprovalPrompt.new(
+        id: "prompt_#{format('%03d', @prompt_counter)}",
+        raw_text: line.strip,
+        detected_patterns: detected_patterns,
+        confidence: confidence,
+        is_menu: numbered_menu?(line)
+      )
+
+      evaluate_and_respond(prompt)
+    end
+
+    def evaluate_and_respond(prompt)
+      rules = @blacklist.rule_contents
+
+      if rules.empty?
+        prompt.approve!
+        @logger.log_approval(prompt)
+        return format_response(prompt)
+      end
+
+      result = @ai_matcher.evaluate(prompt.raw_text, rules)
+
+      if result[:error]
+        prompt.ai_unavailable_approve!
+        @logger.log_ai_failure(prompt, result[:error])
+      elsif result[:matched]
+        prompt.deny!(result[:rule_id])
+        @logger.log_denial(prompt, result[:rule_id])
+      else
+        prompt.approve!
+        @logger.log_approval(prompt)
+      end
+
+      format_response(prompt)
+    end
+
+    def format_response(prompt)
+      {
+        output: "#{prompt.response_sent}\n",
+        is_prompt: true,
+        decision: prompt.decision,
+        response: prompt.response_sent,
+        original_prompt: prompt.raw_text,
+        is_menu: prompt.is_menu
+      }
+    end
+  end
+end

data/lib/aihype/env.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module AIHype
+  module Env
+    # Anthropic API configuration
+    def self.anthropic_api_key
+      ENV['ANTHROPIC_API_KEY']
+    end
+
+    # Model selection
+    # Can be overridden to force a specific model
+    def self.model
+      ENV['AIHYPE_MODEL']
+    end
+
+    # Model selection preference: fast, cheap, balanced, powerful
+    def self.model_preference
+      pref = ENV['AIHYPE_MODEL_PREFERENCE']
+      return :cheap unless pref
+
+      pref.to_sym
+    end
+
+    # Timeout for API requests (in seconds)
+    def self.api_timeout
+      timeout = ENV['AIHYPE_API_TIMEOUT']
+      return 5 unless timeout # Increased to 5 seconds to account for rate limiting
+
+      timeout.to_i
+    end
+
+    # Enable verbose logging
+    def self.verbose?
+      value = ENV['AIHYPE_VERBOSE']
+      ['1', 'true', 'yes'].include?(value&.downcase)
+    end
+
+    # Configuration file path
+    def self.config_path
+      ENV['AIHYPE_CONFIG'] || 'memory/aihype.md'
+    end
+
+    # Log file path
+    def self.log_path
+      ENV['AIHYPE_LOG'] || 'memory/aihype.log'
+    end
+
+    # Rate limiting - requests per minute
+    def self.rate_limit_rpm
+      rpm = ENV['AIHYPE_RATE_LIMIT_RPM']
+      return 50 unless rpm # Default to 50 requests per minute
+
+      rpm.to_i
+    end
+
+    # Rate limiting - window size in seconds
+    def self.rate_limit_window
+      window = ENV['AIHYPE_RATE_LIMIT_WINDOW']
+      return 60 unless window # Default to 60 seconds
+
+      window.to_i
+    end
+
+    # All environment variables used by aihype
+    def self.all
+      {
+        anthropic_api_key: anthropic_api_key,
+        model: model,
+        model_preference: model_preference,
+        api_timeout: api_timeout,
+        verbose: verbose?,
+        config_path: config_path,
+        log_path: log_path,
+        rate_limit_rpm: rate_limit_rpm,
+        rate_limit_window: rate_limit_window
+      }
+    end
+  end
+end

data/lib/aihype/log_entry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module AIHype
+  class LogEntry
+    attr_reader :timestamp, :level, :event_type, :message, :metadata
+
+    VALID_LEVELS = %i[info warning error].freeze
+    VALID_EVENT_TYPES = %i[prompt_detected rule_matched ai_failure memory_loaded].freeze
+
+    def initialize(level:, event_type:, message:, metadata: {})
+      @timestamp = Time.now
+      @level = level
+      @event_type = event_type
+      @message = message
+      @metadata = metadata
+
+      validate!
+    end
+
+    def to_json(*_args)
+      {
+        timestamp: timestamp.iso8601,
+        level: level.to_s.upcase,
+        event_type: event_type.to_s,
+        message: message,
+        metadata: metadata
+      }.to_json
+    end
+
+    def to_stderr
+      "[AIHype] #{level.to_s.upcase}: #{message}"
+    end
+
+    private
+
+    def validate!
+      raise ArgumentError, "Invalid level: #{level}" unless VALID_LEVELS.include?(level)
+      raise ArgumentError, "Invalid event_type: #{event_type}" unless VALID_EVENT_TYPES.include?(event_type)
+    end
+  end
+end

data/lib/aihype/logger.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'log_entry'
+require 'fileutils'
+
+module AIHype
+  class Logger
+    MAX_LOG_SIZE = 10 * 1024 * 1024 # 10MB
+    MAX_LOG_FILES = 5
+
+    def initialize(log_file_path: 'memory/aihype.log', verbose: false)
+      @log_file_path = log_file_path
+      @verbose = verbose
+      ensure_log_directory
+    end
+
+    def log_startup(rules_count, config_path)
+      message = "Loaded #{rules_count} blacklist rules from #{config_path}"
+      entry = LogEntry.new(level: :info, event_type: :memory_loaded, message: message)
+      write(entry)
+    end
+
+    def log_approval(prompt)
+      message = "APPROVED: #{prompt.raw_text}"
+      metadata = { prompt_id: prompt.id, decision: prompt.decision }
+      entry = LogEntry.new(level: :info, event_type: :prompt_detected, message: message, metadata: metadata)
+      write(entry) if @verbose
+    end
+
+    def log_denial(prompt, rule_content)
+      message = "DENIED: #{prompt.raw_text} (matched rule: #{rule_content})"
+      metadata = { prompt_id: prompt.id, rule: rule_content }
+      entry = LogEntry.new(level: :warning, event_type: :rule_matched, message: message, metadata: metadata)
+      write(entry)
+    end
+
+    def log_ai_failure(prompt, error)
+      message = "WARNING: AI unavailable (#{error}), approving all prompts"
+      metadata = { prompt_id: prompt.id, error: error }
+      entry = LogEntry.new(level: :warning, event_type: :ai_failure, message: message, metadata: metadata)
+      write(entry)
+    end
+
+    def log_user_input(input)
+      return unless @verbose
+      # Log raw user input for debugging bidirectional I/O
+      entry = LogEntry.new(level: :debug, event_type: :user_input, message: "User input: #{input.inspect}")
+      write(entry)
+    end
+
+    def log_child_output(output)
+      return unless @verbose
+      # Log raw child output for debugging bidirectional I/O
+      entry = LogEntry.new(level: :debug, event_type: :child_output, message: "Child output: #{output.inspect}")
+      write(entry)
+    end
+
+    private
+
+    def write(entry)
+      $stderr.puts entry.to_stderr
+      write_to_file(entry)
+    end
+
+    def write_to_file(entry)
+      rotate_if_needed
+      File.open(@log_file_path, 'a') do |f|
+        f.puts entry.to_json
+      end
+    rescue Errno::ENOENT
+      ensure_log_directory
+      retry
+    end
+
+    def ensure_log_directory
+      dir = File.dirname(@log_file_path)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    end
+
+    def rotate_if_needed
+      return unless File.exist?(@log_file_path)
+      return unless File.size(@log_file_path) > MAX_LOG_SIZE
+
+      rotate_logs
+    end
+
+    def rotate_logs
+      (MAX_LOG_FILES - 1).downto(1) do |i|
+        old_file = "#{@log_file_path}.#{i}"
+        new_file = "#{@log_file_path}.#{i + 1}"
+        File.rename(old_file, new_file) if File.exist?(old_file)
+      end
+
+      File.rename(@log_file_path, "#{@log_file_path}.1") if File.exist?(@log_file_path)
+
+      # Remove oldest log if we exceed MAX_LOG_FILES
+      oldest = "#{@log_file_path}.#{MAX_LOG_FILES + 1}"
+      File.delete(oldest) if File.exist?(oldest)
+    end
+  end
+end