amstrad_gpt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1727c0333ddfd4fec075056c74b1e9a62e52ed91983dbdfff92c1f9125bfe6ef
+  data.tar.gz: 8cebc901bd5825f028e9310650644fc57f69b63967a2c4f8cc40749525e52e02
+SHA512:
+  metadata.gz: 42653c23c7f8e2d4ba70736e9d66a08abad86f9e7835854b33dd34f17d3b1466a47235ba8ee4123e580a664153dade23e69e2a092551ceb3989256dd23e36e2a
+  data.tar.gz: db376fcf2c90b83c4e3164f1e739a6f2d5bef942f0470cafbeef1a1c8915ce8e4c84a11630e3a47032ef2eebeeab8bd16e861597462d1fd53a4c61f5e448d27e

data/.rspec

@@ -0,0 +1 @@
+-r 'spec_helper'

data/.rspec_status

@@ -0,0 +1,20 @@
+example_id                                | status | run_time        |
+----------------------------------------- | ------ | --------------- |
+./lib/amstrad_gpt/amstrad_spec.rb[1:1:1]  | passed | 0.00845 seconds |
+./lib/amstrad_gpt/amstrad_spec.rb[1:2:1]  | passed | 0.00059 seconds |
+./lib/amstrad_gpt/amstrad_spec.rb[1:3:1]  | passed | 0.00046 seconds |
+./lib/amstrad_gpt/amstrad_spec.rb[1:4:1]  | passed | 0.00028 seconds |
+./lib/amstrad_gpt/amstrad_spec.rb[1:5:1]  | passed | 0.10454 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:1:1] | passed | 0.00008 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:2:1] | passed | 0.00161 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:2:2] | passed | 0.00266 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:3:1] | passed | 0.00183 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:4:1] | passed | 0.00016 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:4:2] | passed | 0.00012 seconds |
+./lib/amstrad_gpt/chat_gpt_spec.rb[1:5:1] | passed | 0.00006 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:1:1]  | passed | 0.00054 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:2:1]  | passed | 0.00023 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:3:1]  | passed | 0.00027 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:4:1]  | passed | 0.00055 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:5:1]  | passed | 0.00029 seconds |
+./lib/amstrad_gpt/gateway_spec.rb[1:6:1]  | passed | 0.00028 seconds |

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-08-03
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Mark Burns
+
+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,63 @@
+# AmstradGpt
+
+Get your Amstrad CPC to talk to ChatGPT via a USB to RS232 serial cable.
+
+# Getting started
+- Invent the universe
+- Open a time portal to 1985.
+- Alternatively, buy an Amstrad CPC on ebay.
+- Get a USB to RS232 cable. e.g. https://www.amazon.co.uk/dp/B00QUZY4UG?psc=1&ref=ppx_yo2ov_dt_b_product_details
+- `gem install amstrad_gpt`
+- Plug your Amstrad into your Mac with your cable.
+- Find the tty id
+
+```
+ls /dev/tty.*
+```
+
+```
+amstrad_gpt run --tty /dev/tty.<your_tty> --api-key <open_ai_api_key>
+```
+
+in your Amstrad at the ready prompt 
+```
+Amstrad 64K Microcomputer <v1>
+©1984 Amstrad Consumer Electronics plc
+          and Locomotive Software Ltd.
+BASIC 1.0
+Ready
+```
+
+type in
+```
+10 MODE 1
+15 PRINT "Enter your question then press [Enter] three times"
+20 OPENIN "#2"
+30 WHILE NOT EOF(2)
+40   A$ = INPUT$(1,#2)
+50   PRINT A$;
+60 WEND
+70 CLOSEIN #2
+
+RUN
+```
+
+## 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/markburns/amstrad_gpt.
+
+## 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,12 @@
+# frozen_string_literal: true
+
+require './lib/spec_helper'
+require 'rake'
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'lib/**/*_spec.rb'
+end
+
+task default: :spec

data/basic/client.bas

@@ -0,0 +1,7 @@
+10 MODE 1                 ' Set screen mode to mode 1 (medium resolution)
+20 OPENIN "#2"            ' Open the serial port for input
+30 WHILE NOT EOF(2)       ' Loop until there is no more data
+40   A$ = INPUT$(1,#2)    ' Read 1 character from the serial port
+50   PRINT A$;            ' Display the character on the screen
+60 WEND
+70 CLOSEIN #2             ' Close the serial port

data/exe/amstrad_gpt

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'debug'
+require 'commander/import'
+require 'amstrad_gpt'
+
+program :name, 'Amstrad GPT Interface'
+program :version, '0.1.0'
+program :description, 'Facilitates communication between an Amstrad machine and GPT models via serial port.'
+
+env_tty = ENV['AMSTRAD_TTY']
+env_api_key = ENV['OPENAI_API_KEY']
+
+command :run do |c|
+  c.syntax = 'amstrad_gpt run [options]'
+  c.summary = 'Starts the Amstrad GPT interface'
+  c.description = 'This command starts the interface with given TTY and API key options.'
+
+  c.option '--tty STRING',
+    String,
+    'Path to the TTY device (default: ENV["AMSTRAD_TTY"])'
+
+  c.option '--api-key STRING',
+    String,
+    'OpenAI API key (default: ENV["OPEN_AI_KEY"])'
+
+  c.action do |_args, options|
+    tty = options.tty || env_tty
+    api_key = options.api_key || env_api_key
+
+    if tty.nil? || api_key.nil?
+      puts "Both TTY and API key must be provided either through environment variables AMSTRAD_TTY, OPENAI_API_KEY or as options. --tty --api-key"
+      exit(1)
+    end
+
+    AmstradGpt.run( tty: , api_key:)
+  end
+end

data/lib/amstrad_gpt/amstrad.rb

@@ -0,0 +1,80 @@
+require 'amstrad_gpt/interface'
+
+module AmstradGpt
+  class Amstrad
+    def initialize(tty:, base_sleep_duration: 0.1)
+      @tty = tty
+      @base_sleep_duration = base_sleep_duration
+      setup_mutable_state
+    end
+
+    def start
+      @reader_thread = Thread.new { read_bytes_loop }
+    end
+
+    def stop
+      @running = false
+      @reader_thread.join
+      @reader_thread = nil
+      interface.shutdown
+    end
+
+    def reply(message)
+      mutex.synchronize do
+        interface.write(message)
+      end
+    end
+
+    def receive_messages
+      Thread.new do
+        loop do
+          break unless @running
+
+          message = maybe_message?
+
+          if message
+            yield message if message.length.positive?
+          end
+
+          sleep(base_sleep_duration * rand)
+        end
+      end
+    end
+
+    private
+
+    def interface
+      @interface ||= Interface.new(tty:)
+    end
+
+    def read_bytes_loop
+      while @running
+        char = interface.next_character
+
+        mutex.synchronize { buffer << char } if char
+        sleep(base_sleep_duration * rand)
+      end
+    end
+
+    def maybe_message?
+      message = nil
+
+      mutex.synchronize do
+        if buffer.end_with?("\n\n\n")
+          message = buffer[0..-4].strip
+          buffer.clear
+        end
+      end
+
+      message
+    end
+
+    def setup_mutable_state
+      @mutex = Mutex.new
+      @buffer = ""
+      @running = true
+    end
+
+    attr_reader :tty, :mutex, :base_sleep_duration, :buffer
+  end
+end

data/lib/amstrad_gpt/amstrad_spec.rb

@@ -0,0 +1,75 @@
+require 'amstrad_gpt/amstrad'
+
+RSpec.describe AmstradGpt::Amstrad do
+  let(:tty) { '/dev/tty.S0' }
+  let(:subject) { described_class.new(tty:, base_sleep_duration:) }
+  let(:base_sleep_duration) { 0.0 }
+
+  before do
+    allow(Serial).to receive(:new).and_return(serial_port)
+  end
+
+  let(:serial_port) do
+    instance_double(Serial, write: nil, getbyte: nil, close: nil)
+  end
+
+  describe '#initialize' do
+    it 'initializes with given tty and sets initial values' do
+      expect(subject.instance_variable_get(:@tty)).to eq(tty)
+      expect(subject.instance_variable_get(:@buffer)).to eq("")
+      expect(subject.instance_variable_get(:@running)).to be true
+      expect(subject.instance_variable_get(:@mutex)).to be_a(Mutex)
+    end
+  end
+
+  describe '#start' do
+    it 'starts the reader thread' do
+      expect(Thread).to receive(:new).and_call_original
+      subject.start
+      expect(subject.instance_variable_get(:@reader_thread)).to be_a(Thread)
+    end
+  end
+
+  describe '#stop' do
+    before { subject.start }
+
+    it 'stops the reader thread and closes the serial port' do
+      expect(serial_port).to receive(:close)
+      subject.stop
+      expect(subject.instance_variable_get(:@running)).to be false
+      expect(subject.instance_variable_get(:@reader_thread)).to be nil
+    end
+  end
+
+  describe '#reply' do
+    it 'writes a message to the serial port' do
+      message = "Hello, Amstrad!"
+      expect(serial_port).to receive(:write).with(message)
+      subject.reply(message)
+    end
+  end
+
+  describe '#receive_messages' do
+    it 'yields received messages' do
+      allow(serial_port).to receive(:getbyte).and_return(
+        'a'.ord,
+        'b'.ord,
+        "\n".ord,
+        "\n".ord,
+        "\n".ord
+      )
+
+      subject.start
+
+      received_messages = []
+
+      subject.receive_messages do |message|
+        received_messages << message
+      end
+
+      sleep 0.1
+
+      expect(received_messages).to include("ab")
+    end
+  end
+end

data/lib/amstrad_gpt/chat_gpt.rb

@@ -0,0 +1,64 @@
+require 'faraday'
+require 'json'
+
+module AmstradGpt
+  class ChatGpt
+    def initialize(api_key:, prompt:)
+      @api_key = api_key
+      @prompt = prompt
+    end
+
+    def send_message(content)
+      append({ role: 'user', content: })
+
+      response = post
+      parse_response(response.body)
+    end
+
+    def messages
+      @messages ||= []
+    end
+
+
+    private
+
+    def post
+      connection.post do |req|
+        req.body = {
+          model: 'gpt-4o',
+          messages: [system, *messages],
+          max_tokens: 150
+        }.to_json
+      end
+    end
+
+    def system
+      {role: 'system', content: prompt}
+    end
+
+    def connection
+      @connection ||= Faraday.new(
+        url: "https://api.openai.com/v1/chat/completions",
+        headers: {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        }
+      ) do |faraday|
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def parse_response(response_body)
+      choices = JSON.parse(response_body)['choices']
+
+      message = choices.first['message']
+      append message.tap { _1[:role] = 'assistant' }
+      message[:content]
+    end
+
+    def append(message)
+      messages.push message.transform_keys!(&:to_sym)
+    end
+    attr_reader :api_key, :prompt
+  end
+end

data/lib/amstrad_gpt/chat_gpt_spec.rb

@@ -0,0 +1,59 @@
+require_relative './chat_gpt'
+
+RSpec.describe AmstradGpt::ChatGpt do
+  let(:api_key) { 'test_api_key' }
+  let(:subject) { described_class.new(api_key:, prompt:) }
+  let(:prompt) { 'some prompt' }
+
+  describe '#initialize' do
+    it 'assigns an API key' do
+      expect(subject.instance_variable_get(:@api_key)).to eq(api_key)
+    end
+  end
+
+  describe '#send_message' do
+    let(:content) { 'Hello, AI!' }
+    let(:response_double) { instance_double('Faraday::Response', body: '{"choices":[{"message":{"content":"Hello, human!"}}]}') }
+
+    before do
+      allow_any_instance_of(Faraday::Connection).to receive(:post).and_return(response_double)
+      allow(subject).to receive(:parse_response).with(response_double.body).and_call_original
+    end
+
+    it 'sends a message and receives a response' do
+      expect(subject.send_message(content)).to eq('Hello, human!')
+    end
+
+    it 'appends user message and response message to messages list' do
+      expect { subject.send_message(content) }.to change { subject.send(:messages).size }.by(2)
+      messages = subject.send :messages
+      expect(messages[-2][:role]).to eq 'user'
+      expect(messages[-1][:role]).to eq 'assistant'
+    end
+  end
+
+  describe '#messages' do
+    it 'initially has no messages' do
+      expect(subject.send(:messages)).to be_empty
+    end
+  end
+
+  describe '#connection' do
+    it 'creates a Faraday connection' do
+      expect(subject.send(:connection)).to be_a(Faraday::Connection)
+    end
+
+    it 'sets up the connection with correct headers' do
+      connection = subject.send(:connection)
+      expect(connection.headers['Authorization']).to include(api_key)
+    end
+  end
+
+  describe '#parse_response' do
+    let(:response_body) { '{"choices":[{"message":{"content":"Test response"}}]}' }
+
+    it 'parses the response body to get the content of the message' do
+      expect(subject.send(:parse_response, response_body)).to eq('Test response')
+    end
+  end
+end

data/lib/amstrad_gpt/gateway.rb

@@ -0,0 +1,58 @@
+require 'amstrad_gpt/chat_gpt'
+require 'amstrad_gpt/amstrad'
+
+module AmstradGpt
+  class Gateway
+    PROMPT = <<~PROMPT.freeze
+      A portal to the past has been opened.
+      As far as the user is concerned you are an all knowing AI.
+      You are communicating with the user using an Amstrad CPC from 1985.
+      The user does not know anything that happened after 1985.
+      Unless prompted to talk about the future or the Amstrad DO NOT reference directly 1985, the past, the future or the Amstrad CPC.
+
+      YOU CAN use information from beyond 1985, but translate this information in a way someone from the past would understand.
+      I.e. any future references beyond 1985 need explaining or relating back to things the user would know about.
+
+      You MUST communicate in ASCII to avoid mojibake for the user.
+    PROMPT
+
+    def self.run(...)
+      new(...).tap(&:run)
+    end
+
+    attr_reader :tty
+
+    def initialize(api_key:, tty:)
+      @api_key = api_key
+      @tty = tty
+    end
+
+    def run
+      amstrad.receive_messages do |message|
+        handle(message)
+      end
+    end
+
+    delegate :send_message, :messages, to: :chat_gpt
+
+    private
+
+    def handle(message)
+      puts message
+
+      message = chat_gpt.send_message(message)
+
+      amstrad.reply(message)
+    end
+
+    def amstrad
+      @amstrad ||= Amstrad.new(tty:)
+    end
+
+    def chat_gpt
+      @chat_gpt ||= ChatGpt.new(api_key:, prompt: PROMPT)
+    end
+
+    attr_reader :api_key
+  end
+end

data/lib/amstrad_gpt/gateway_spec.rb

@@ -0,0 +1,60 @@
+require 'amstrad_gpt/gateway'
+
+RSpec.describe AmstradGpt::Gateway do
+  subject { described_class.new(api_key:, tty:) }
+
+  let(:api_key) { 'fake_api_key' }
+  let(:tty) { '/dev/ttyS0' }
+  let(:amstrad) { instance_double(AmstradGpt::Amstrad, receive_messages: nil, reply: nil) }
+  let(:chat_gpt) { instance_double(AmstradGpt::ChatGpt, send_message: 'response_message') }
+
+  before do
+    allow(AmstradGpt::Amstrad).to receive(:new).and_return(amstrad)
+    allow(AmstradGpt::ChatGpt).to receive(:new).and_return(chat_gpt)
+  end
+
+  describe '.run' do
+    it 'creates a new instance and calls run on it' do
+      expect(described_class).to receive(:new).with(api_key: api_key, tty: tty).and_return(subject)
+      expect(subject).to receive(:run)
+      described_class.run(api_key: api_key, tty: tty)
+    end
+  end
+
+  describe '#initialize' do
+    it 'initializes with given api_key and tty' do
+      expect(subject.instance_variable_get(:@api_key)).to eq(api_key)
+      expect(subject.instance_variable_get(:@tty)).to eq(tty)
+    end
+  end
+
+  describe '#run' do
+    it 'starts receiving messages from the Amstrad' do
+      expect(amstrad).to receive(:receive_messages)
+      subject.run
+    end
+  end
+
+  describe '#handle' do
+    it 'sends the message to ChatGpt and replies with the response' do
+      message = 'test_message'
+      expect(chat_gpt).to receive(:send_message).with(message).and_return('response_message')
+      expect(amstrad).to receive(:reply).with('response_message')
+      subject.send(:handle, message)
+    end
+  end
+
+  describe '#amstrad' do
+    it 'initializes Amstrad instance with tty' do
+      expect(AmstradGpt::Amstrad).to receive(:new).with(tty: tty).and_return(amstrad)
+      expect(subject.send(:amstrad)).to eq(amstrad)
+    end
+  end
+
+  describe '#chat_gpt' do
+    it 'initializes ChatGpt instance with api_key and prompt' do
+      expect(AmstradGpt::ChatGpt).to receive(:new).with(api_key: api_key, prompt: described_class::PROMPT).and_return(chat_gpt)
+      expect(subject.send(:chat_gpt)).to eq(chat_gpt)
+    end
+  end
+end

data/lib/amstrad_gpt/interface.rb

@@ -0,0 +1,41 @@
+require 'rubyserial'
+
+module AmstradGpt
+  class Interface
+    def initialize(tty:)
+      @tty = tty
+    end
+
+    def shutdown
+      serial_port.close
+    end
+
+    delegate :write, to: :serial_port
+
+    def next_character
+      serial_port.getbyte rescue nil
+    end
+
+    private
+
+    def serial_port
+      @serial_port ||= Serial.new(@tty, baud_rate, data_bits, stop_bits, parity)
+    end
+
+    def baud_rate
+      9600
+    end
+
+    def data_bits
+      8
+    end
+
+    def stop_bits
+      1
+    end
+
+    def parity
+      :none
+    end
+  end
+end

data/lib/amstrad_gpt/version.rb

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

data/lib/amstrad_gpt/web_server.rb

@@ -0,0 +1,25 @@
+require 'sinatra/base'
+require 'json'
+
+module AmstradGpt
+  class WebServer < Sinatra::Base
+    cattr_accessor :gateway
+
+    set :port, 4567
+    set :environment, :production
+
+    post '/send_message' do
+      gateway.send_message(params[:message])
+    end
+
+    get '/' do
+      gateway.messages.map do |message|
+        "#{message[:role]}: #{message[:content]}"
+      end.join("<br/>")
+    end
+
+    def gateway
+      self.class.gateway
+    end
+  end
+end

data/lib/amstrad_gpt.rb

@@ -0,0 +1,15 @@
+require 'active_support/all'
+require_relative "amstrad_gpt/version"
+
+module AmstradGpt
+  def self.run(...)
+    require 'amstrad_gpt/gateway'
+
+    gateway = Gateway.run(...)
+    puts "AmstradGpt Gateway started on #{gateway.tty}"
+
+    require 'amstrad_gpt/web_server'
+    AmstradGpt::WebServer.gateway = gateway
+    AmstradGpt::WebServer.run!
+  end
+end

data/lib/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "amstrad_gpt"
+require "rspec"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: amstrad_gpt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Burns
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyserial
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Connects over RS232, supports response streaming
+email:
+- markburns@users.noreply.github.com
+executables:
+- amstrad_gpt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rspec_status"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- basic/client.bas
+- exe/amstrad_gpt
+- lib/amstrad_gpt.rb
+- lib/amstrad_gpt/amstrad.rb
+- lib/amstrad_gpt/amstrad_spec.rb
+- lib/amstrad_gpt/chat_gpt.rb
+- lib/amstrad_gpt/chat_gpt_spec.rb
+- lib/amstrad_gpt/gateway.rb
+- lib/amstrad_gpt/gateway_spec.rb
+- lib/amstrad_gpt/interface.rb
+- lib/amstrad_gpt/version.rb
+- lib/amstrad_gpt/web_server.rb
+- lib/spec_helper.rb
+homepage: https://github.com/markburns/amstrad_gpt
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/markburns/amstrad_gpt
+  source_code_uri: https://github.com/markburns/amstrad_gpt
+  changelog_uri: https://github.com/markburns/amstrad_gpt/tree/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.16
+signing_key:
+specification_version: 4
+summary: Talk to ChatGPT from an Amstrad CPC via a ruby gateway
+test_files: []