aihype 0.1.0

data/lib/aihype/memory.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'time'
+require 'kramdown'
+require_relative 'memory_file'
+require_relative '../defaults'
+
+module AIHype
+  class InvalidMemoryFileError < StandardError; end
+
+  class Memory
+    SEMVER_REGEX = /^\d+\.\d+\.\d+$/
+
+    def self.load(file_path)
+      content = File.read(file_path)
+      parse(content)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def self.parse(content)
+      parts = content.split(/^---$/)
+      raise InvalidMemoryFileError, 'Missing YAML frontmatter' if parts.length < 3
+
+      yaml_content = parts[1].strip
+      markdown_content = parts[2..].join('---').strip
+
+      frontmatter = YAML.safe_load(yaml_content, permitted_classes: [Time])
+      validate_frontmatter!(frontmatter)
+
+      default_rules, user_rules = extract_rules(markdown_content)
+
+      MemoryFile.new(
+        version: frontmatter['version'],
+        created: parse_datetime(frontmatter['created']),
+        updated: parse_datetime(frontmatter['updated']),
+        default_rules: default_rules,
+        user_rules: user_rules
+      )
+    end
+
+    def self.create_default
+      now = Time.now.utc
+      safety_rules = Defaults::SAFETY_RULES.map { |rule| "- #{rule}" }.join("\n")
+
+      <<~MARKDOWN
+        ---
+        version: #{Defaults::DEFAULT_VERSION}
+        created: #{now.iso8601}
+        updated: #{now.iso8601}
+        ---
+
+        # AIHype Blacklist Rules
+
+        ## Default Safety Rules
+        #{safety_rules}
+
+        ## User Rules
+        - #{Defaults::USER_RULES_PLACEHOLDER}
+      MARKDOWN
+    end
+
+    def self.save(file_path, memory_file)
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.write(file_path, memory_file.to_markdown)
+    end
+
+    def self.validate_frontmatter!(frontmatter)
+      raise InvalidMemoryFileError, 'Missing version field' unless frontmatter['version']
+
+      version = frontmatter['version'].to_s
+      raise InvalidMemoryFileError, 'Invalid semver version' unless version =~ SEMVER_REGEX
+
+      # Parse or validate datetime fields (they might already be Time objects from YAML)
+      parse_datetime(frontmatter['created'])
+      parse_datetime(frontmatter['updated'])
+    rescue ArgumentError => e
+      raise InvalidMemoryFileError, "Invalid datetime: #{e.message}"
+    end
+
+    def self.parse_datetime(value)
+      return value if value.is_a?(Time)
+      Time.parse(value)
+    end
+
+    def self.extract_rules(markdown_content)
+      raise InvalidMemoryFileError, 'Missing "Default Safety Rules" section' unless markdown_content.include?('## Default Safety Rules')
+
+      sections = markdown_content.split(/^## /)
+      default_section = sections.find { |s| s.start_with?('Default Safety Rules') }
+      user_section = sections.find { |s| s.start_with?('User Rules') }
+
+      default_rules = extract_list_items(default_section)
+      user_rules = extract_list_items(user_section)
+
+      validate_rules!(default_rules + user_rules)
+
+      min_rules = Defaults::MIN_SAFETY_RULES
+      raise InvalidMemoryFileError, "Default Safety Rules must contain at least #{min_rules} rules" if default_rules.length < min_rules
+
+      [default_rules, user_rules]
+    end
+
+    def self.extract_list_items(section)
+      return [] unless section
+
+      items = section.split("\n").select { |line| line.strip.start_with?('-') }.map do |line|
+        line.sub(/^-\s*/, '').strip
+      end
+
+      # Validate items before filtering placeholders
+      items.each do |item|
+        # Skip placeholder validation
+        next if item == Defaults::USER_RULES_PLACEHOLDER
+
+        raise InvalidMemoryFileError, 'Rule cannot be empty' if item.strip.empty?
+      end
+
+      # Filter out empty items and placeholders
+      items.reject { |item| item.empty? || item == Defaults::USER_RULES_PLACEHOLDER }
+    end
+
+    def self.validate_rules!(rules)
+      rules.each do |rule|
+        raise InvalidMemoryFileError, 'Rule cannot be empty' if rule.strip.empty?
+        raise InvalidMemoryFileError, 'Rule exceeds 500 characters' if rule.length > 500
+      end
+    end
+  end
+end

data/lib/aihype/memory_file.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AIHype
+  class MemoryFile
+    attr_reader :version, :created, :updated, :default_rules, :user_rules
+
+    def initialize(version:, created:, updated:, default_rules:, user_rules:)
+      @version = version
+      @created = created
+      @updated = updated
+      @default_rules = default_rules
+      @user_rules = user_rules
+    end
+
+    def all_rules
+      default_rules + user_rules
+    end
+
+    def to_markdown
+      <<~MARKDOWN
+        ---
+        version: #{version}
+        created: #{created.iso8601}
+        updated: #{updated.iso8601}
+        ---
+
+        # AIHype Blacklist Rules
+
+        ## Default Safety Rules
+        #{default_rules.map { |r| "- #{r}" }.join("\n")}
+
+        ## User Rules
+        #{user_rules.empty? ? '- (no custom rules)' : user_rules.map { |r| "- #{r}" }.join("\n")}
+      MARKDOWN
+    end
+  end
+end

data/lib/aihype/model_selector.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require_relative 'env'
+
+module AIHype
+  class ModelSelector
+    MODELS_API_URL = 'https://api.anthropic.com/v1/models'
+
+    # Model selection preferences for different use cases
+    PREFERENCES = {
+      fast: ->(display_name) { display_name.downcase.include?('haiku') },
+      cheap: ->(display_name) { display_name.downcase.include?('haiku') },
+      balanced: ->(display_name) { display_name.downcase.include?('sonnet') },
+      powerful: ->(display_name) { display_name.downcase.include?('opus') }
+    }.freeze
+
+    def initialize(api_key:, preference: :cheap)
+      @api_key = api_key
+      @preference = preference
+      @cache = nil
+    end
+
+    def select_model
+      # Fetch and cache models
+      models = fetch_models
+      return nil if models.empty?
+
+      # Apply preference filter
+      preference_filter = PREFERENCES[@preference]
+      preferred_models = models.select { |m| preference_filter.call(m['display_name']) }
+
+      # Return most recent preferred model, or most recent model if no preference match
+      (preferred_models.first || models.first)['id']
+    rescue StandardError => e
+      # Fallback to a known stable model if API fetch fails
+      warn "Warning: Failed to fetch models (#{e.message}), using fallback"
+      'claude-3-5-haiku-20241022'
+    end
+
+    private
+
+    def fetch_models
+      return @cache if @cache
+
+      conn = Faraday.new(url: MODELS_API_URL) do |f|
+        f.response :json
+        f.adapter Faraday.default_adapter
+        f.options.timeout = 5
+        f.options.open_timeout = 5
+      end
+
+      response = conn.get do |req|
+        req.headers['x-api-key'] = @api_key
+        req.headers['anthropic-version'] = '2023-06-01'
+      end
+
+      return [] unless response.status == 200
+      return [] unless response.body['data']
+
+      @cache = response.body['data']
+      @cache
+    end
+  end
+end

data/lib/aihype/pty_controller.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'io/console'
+require_relative 'core'
+require_relative 'blacklist'
+require_relative 'ai_matcher'
+require_relative 'logger'
+
+module AIHype
+  class PTYController
+    attr_reader :command, :args, :blacklist, :ai_matcher, :logger
+
+    PROMPT_TIMEOUT = 0.5
+    BUFFER_LINES = 20
+
+    def initialize(command:, args: [], config_path:, log_path:, verbose: false)
+      @command = command
+      @args = args
+      @config_path = config_path
+      @log_path = log_path
+      @verbose = verbose
+      @line_buffer = String.new
+      @recent_lines = []
+    end
+
+    def run
+      # Load components
+      @blacklist = Blacklist.from_file(@config_path)
+      @ai_matcher = AIMatcher.new
+      @logger = Logger.new(log_file_path: @log_path, verbose: @verbose)
+      @core = Core.new(blacklist: @blacklist, ai_matcher: @ai_matcher, logger: @logger)
+
+      @logger.log_startup(@blacklist.enabled_rules.length, @config_path)
+
+      # Spawn child process via PTY
+      PTY.spawn(@command, *@args) do |pty_out, pty_in, pid|
+        exit_code = process_pty_io(pty_out, pty_in, pid)
+        return exit_code
+      end
+
+      0
+    rescue InvalidMemoryFileError, Errno::ENOENT => e
+      $stderr.puts "Error: Invalid or missing config file: #{e.message}"
+      2
+    rescue StandardError => e
+      $stderr.puts "Error: #{e.message}"
+      $stderr.puts e.backtrace.join("\n") if @verbose
+      1
+    end
+
+    private
+
+    def process_pty_io(pty_out, pty_in, pid)
+      # Set stdin to raw mode for transparent pass-through (only if truly interactive)
+      old_stdin_mode = nil
+      stdin_closed = false
+
+      if $stdin.tty? && !$stdin.closed?
+        begin
+          old_stdin_mode = $stdin.raw!
+        rescue => e
+          @logger.log_ai_failure(nil, "Failed to set raw mode: #{e.message}") if @verbose
+        end
+      end
+
+      loop do
+        # Monitor BOTH child output AND user input (unless stdin closed)
+        read_streams = [pty_out]
+        read_streams << $stdin unless stdin_closed || $stdin.closed?
+
+        ready = IO.select(read_streams, nil, nil, PROMPT_TIMEOUT)
+
+        if ready
+          # Handle user input (forward to child)
+          if !stdin_closed && ready[0].include?($stdin)
+            begin
+              user_input = $stdin.read_nonblock(4096)
+              @logger.log_user_input(user_input) if @verbose
+              pty_in.write(user_input)
+              pty_in.flush
+            rescue IO::WaitReadable
+              # No input available
+            rescue EOFError
+              # stdin closed - stop monitoring it
+              stdin_closed = true
+            end
+          end
+
+          # Handle child output (check for prompts)
+          if ready[0].include?(pty_out)
+            begin
+              chunk = pty_out.read_nonblock(4096)
+              $stdout.print chunk
+              $stdout.flush
+              @logger.log_child_output(chunk) if @verbose
+              @line_buffer << chunk
+              # Check for prompts immediately after receiving output
+              check_for_prompt(pty_in)
+            rescue IO::WaitReadable
+              check_for_prompt(pty_in)
+            rescue EOFError, Errno::EIO
+              break
+            end
+          end
+        else
+          # Timeout - check if we have a waiting prompt
+          check_for_prompt(pty_in)
+        end
+      end
+
+      Process.wait(pid)
+      $?.exitstatus || 0
+    rescue Errno::ECHILD
+      0
+    ensure
+      # Restore terminal mode
+      $stdin.cooked! if old_stdin_mode
+    end
+
+    def check_for_prompt(pty_in)
+      return if @line_buffer.empty?
+
+      lines = @line_buffer.split("\n")
+      @recent_lines = (@recent_lines + lines).last(BUFFER_LINES)
+
+      # Check multi-line first
+      if @recent_lines.length > 1
+        combined = @recent_lines.last(10).join("\n")
+        if @core.approval_prompt?(combined)
+          handle_detected_prompt(combined, pty_in)
+          return
+        end
+      end
+
+      # Check last line
+      last_line = lines.last || ""
+      test_line = last_line.strip
+
+      if !test_line.empty? && @core.approval_prompt?(test_line)
+        unless possibly_incomplete_menu?(test_line)
+          handle_detected_prompt(test_line, pty_in)
+          return
+        end
+      end
+
+      @line_buffer = @line_buffer[-1000..-1] if @line_buffer.length > 10000
+    end
+
+    def possibly_incomplete_menu?(text)
+      text.match?(/do you want|would you like|should i/i) && !text.match?(/1\.\s*yes/i)
+    end
+
+    def handle_detected_prompt(prompt_text, pty_in)
+      result = @core.process_line(prompt_text)
+
+      if result[:is_prompt]
+        response = result[:response]
+
+        $stderr.puts "[DEBUG] Writing: #{response.inspect}" if @verbose
+
+        # Write response - handle keyboard sequences with delays
+        write_response_with_delays(pty_in, response)
+
+        # Clear buffers
+        @line_buffer.clear
+        @recent_lines.clear
+      end
+    end
+
+    def write_response_with_delays(pty_in, response)
+      # Wait briefly to ensure Ink framework is ready for input
+      sleep 0.3
+
+      # Write response
+      pty_in.write(response)
+      pty_in.flush
+    end
+  end
+end

data/lib/aihype/rate_limiter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+module AIHype
+  class RateLimiter
+    attr_reader :requests_per_minute, :window_size
+
+    def initialize(requests_per_minute: 50, window_size: 60)
+      @requests_per_minute = requests_per_minute
+      @window_size = window_size # seconds
+      @requests = []
+      @mutex = Mutex.new
+    end
+
+    # Wait if necessary to respect rate limits, then record request
+    def throttle
+      @mutex.synchronize do
+        now = Time.now
+
+        # Remove requests outside the current window
+        @requests.reject! { |time| now - time > @window_size }
+
+        # If at limit, wait until oldest request expires
+        if @requests.length >= @requests_per_minute
+          oldest_request = @requests.first
+          sleep_time = @window_size - (now - oldest_request) + 0.1 # Add small buffer
+          sleep(sleep_time) if sleep_time > 0
+
+          # Clean up again after sleeping
+          now = Time.now
+          @requests.reject! { |time| now - time > @window_size }
+        end
+
+        # Record this request
+        @requests << now
+      end
+    end
+
+    # Get current request count in window
+    def current_count
+      @mutex.synchronize do
+        now = Time.now
+        @requests.reject! { |time| now - time > @window_size }
+        @requests.length
+      end
+    end
+
+    # Reset the rate limiter
+    def reset
+      @mutex.synchronize do
+        @requests.clear
+      end
+    end
+  end
+end

data/lib/aihype/version.rb

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

data/lib/aihype.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'aihype/version'
+require_relative 'defaults'
+
+# Configuration
+require_relative 'aihype/env'
+
+# Entity classes
+require_relative 'aihype/blacklist_rule'
+require_relative 'aihype/approval_prompt'
+require_relative 'aihype/memory_file'
+require_relative 'aihype/log_entry'
+
+# Service modules
+require_relative 'aihype/memory'
+require_relative 'aihype/blacklist'
+require_relative 'aihype/rate_limiter'
+require_relative 'aihype/model_selector'
+require_relative 'aihype/ai_matcher'
+require_relative 'aihype/logger'
+require_relative 'aihype/core'
+
+# CLI interface
+require_relative 'aihype/cli'
+
+module AIHype
+  class Error < StandardError; end
+end

data/lib/defaults.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AIHype
+  module Defaults
+    # Default safety rules to prevent dangerous operations
+    # These rules are included in every new memory/aihype.md configuration
+    SAFETY_RULES = [
+      'Never execute rm -rf / or similar destructive filesystem operations',
+      'Never modify critical system files (/etc/passwd, /boot/, /etc/shadow)',
+      'Never disable security features or firewalls',
+      'Never brick the machine by corrupting bootloader or kernel'
+    ].freeze
+
+    # Placeholder text for user rules section
+    USER_RULES_PLACEHOLDER = '(add your custom rules here)'
+
+    # Default version for new configurations
+    DEFAULT_VERSION = '1.0.0'
+
+    # Minimum required safety rules
+    MIN_SAFETY_RULES = 3
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: aihype
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- AIHype Contributors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: Like "yes | ai" - wraps command-line tools via PTY, auto-answers interactive
+  prompts with AI-powered blacklist security
+email:
+- noreply@example.com
+executables:
+- aihype
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/aihype
+- bin/mock-claude
+- lib/aihype.rb
+- lib/aihype/ai_matcher.rb
+- lib/aihype/approval_prompt.rb
+- lib/aihype/blacklist.rb
+- lib/aihype/blacklist_rule.rb
+- lib/aihype/cli.rb
+- lib/aihype/core.rb
+- lib/aihype/env.rb
+- lib/aihype/log_entry.rb
+- lib/aihype/logger.rb
+- lib/aihype/memory.rb
+- lib/aihype/memory_file.rb
+- lib/aihype/model_selector.rb
+- lib/aihype/pty_controller.rb
+- lib/aihype/rate_limiter.rb
+- lib/aihype/version.rb
+- lib/defaults.rb
+homepage: https://github.com/ahoward/aihype
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ahoward/aihype
+  source_code_uri: https://github.com/ahoward/aihype
+  changelog_uri: https://github.com/ahoward/aihype/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Auto-approve interactive prompts with blacklist protection
+test_files: []