ask-terminal 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2494b8eb2ebc4400cbb63467cf36a11a2dd98d5707a3d7130449477967ee338
+  data.tar.gz: d5d6b77593f1e70840b68a828b9bfaa400cd8272fb682be9ea25e3699f490bf1
+SHA512:
+  metadata.gz: 123439471a5bc89122297402bedc6115bef1f47cb04124e220e9d348ef04ffd414eb32d2abc8ce686704d64a49b8432a5d76f8f7ebcd52a1c59ca5e54542c3f3
+  data.tar.gz: 19ef2976881a3a74c9e573b727e135dc7f72947739c0fbee530ad027c88e902864734cbe497e54a7de5f27fb924799510cce6ae84f1b6af0836374011e31ae1b

data/CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+All notable changes to ask-terminal are documented here, following
+the keep-a-changelog format.
+
+## [Unreleased]
+
+## [0.2.0] - 2026-08-12
+
+### Changed
+
+- **The protocol client lives in `ask-session-protocol`** (the retired
+  ask-session-client merged into it) — `Client` and `Host` are there;
+  ask-terminal keeps thin aliases
+  (`Ask::Terminal::Client` = `Ask::SessionProtocol::Client`), so existing
+  references keep working.
+## [0.1.2] - 2026-08-11
+
+### Added
+
+- **Spawned hosts are multi-client attachable by default** — `ask` starts
+  the host with a unix socket (unique per spawn under
+  `~/.ask-app-server/sockets/`, or `ASK_APP_SERVER_SOCKET` when set) and
+  prints the path on startup, so the web console, bots, or a second
+  terminal can attach to the same live sessions. `Host.spawn(socket:)`
+  controls it: `true` (default), a custom path, or `false` to disable.
+
+## [0.1.1] - 2026-08-11
+
+### Changed
+
+- **The command is now `ask`** — the terminal client's primary executable
+  is the short brand name; `ask-terminal` remains installed as a long
+  alias. Both behave identically. CLI logic moved into
+  `Ask::Terminal::CLI`.
+
+## [0.1.0] - 2026-08-11
+
+### Added
+
+- **`Client`** — a thin NDJSON protocol client over the host's stdio or a
+  unix socket: request/response correlation by id, notification queue,
+  protocol error handling, and connection-close semantics (sentinel
+  notification + `ConnectionClosed` on pending requests).
+- **`Host`** — spawns `ask-app-server` as a subprocess (`Gem.bin_path`,
+  PATH fallback) or attaches to a running host over its unix socket.
+- **`Renderer`** — canonical session events rendered as ANSI terminal
+  output: streaming model/thinking deltas, tool lifecycle with duration
+  and truncated output, approval and plan interactions, todos progress,
+  turn lifecycle.
+- **`Repl`** — the interactive loop: prompt → `session/send` → stream
+  events → resolve approvals (y/N) and plan proposals (y/N) inline via the
+  canonical `interaction/*` and `plan/*` methods → prompt again. Commands:
+  `/approve`, `/reject`, `/plan-approve`, `/plan-reject`, `/abort`,
+  `/status`, `/sessions`, `/exit`; Ctrl-C aborts the running turn.
+- **`ask-terminal` executable** — `--host stdio|socket`, `--socket PATH`,
+  `--workspace`, `--model`, `--approval`.
+- **Test suite** — 37 tests: protocol client against a scripted peer,
+  renderer coverage, repl interaction flows (approval/plan/commands), and
+  end-to-end integration over a real in-process SocketServer host
+  (handshake, session lifecycle, approval streaming, two clients sharing
+  one session).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaka Ruto
+
+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,107 @@
+# ask-terminal
+
+**The terminal client of the ask ecosystem.** An interactive terminal
+coding agent that speaks the canonical
+[ask-session-protocol](https://github.com/ask-rb/ask-session-protocol) and
+nothing else — no runtime, no sessions, no tools. The host
+(ask-app-server) owns all of it; this client just renders events and
+sends requests.
+
+```
+ask> fix the failing test in spec/models
+› bash grep -rn "failing" spec/
+  └ bash (120ms)
+    ...
+── turn completed ──
+```
+
+## Why this exists
+
+The ask ecosystem's architecture is *one session host, one canonical
+protocol, many thin clients*. ask-terminal is the first client and the
+proof: it can attach to the same live sessions as the web console, a bot,
+or an IDE — each client receives every event exactly once via its own
+delivery cursor, and any client can resolve an approval or a plan proposal
+by id.
+
+## Usage
+
+Two ways to reach a host (the command is `ask`; `ask-terminal` is the long
+alias — both are installed by the gem):
+
+```bash
+# Spawn a host over stdio — it also exposes a unix socket for
+# multi-client attach, and prints the path on startup:
+ask
+#   host socket: ~/.ask-app-server/sockets/4f3a9c2b1d0e8f7a.sock
+
+# Attach to an already-running host over its unix socket (multi-client)
+ask --socket ~/.ask-app-server/sockets/4f3a9c2b1d0e8f7a.sock
+
+# Options
+ask --workspace ~/code/myapp --model deepseek-v4-flash --approval on_request
+```
+
+Every spawned host is attachable: the web console, a bot, or a second
+terminal can connect to the same live sessions (`ASK_APP_SERVER_SOCKET`
+pins the path; `Host.spawn(socket: false)` disables it).
+
+| Flag | Default | Description |
+|---|---|---|
+| `--host MODE` | `stdio` | `stdio` (spawn the host) or `socket` (attach) |
+| `--socket PATH` | — | Attach to a running host (implies `--host socket`) |
+| `-w, --workspace DIR` | current dir | Workspace for `session/create` |
+| `--model MODEL` | host default | Model identifier |
+| `--approval MODE` | `on_request` | `on_request` \| `off` \| `auto` |
+
+## Interactive commands
+
+| Command | Description |
+|---|---|
+| `/approve [id]` | Approve a pending approval (all when no id) |
+| `/reject [id]` | Reject a pending approval (all when no id) |
+| `/plan-approve` · `/plan-reject` | Resolve the pending plan proposal |
+| `/abort` | Abort the running turn |
+| `/status` | Show workspace and pending interactions |
+| `/sessions` | List host sessions |
+| `/exit` | Quit |
+
+Approvals and plan proposals also resolve inline: when the host pauses a
+turn, the terminal asks `Approve bash (act_1)? [y/N]` and resolves through
+the canonical `interaction/approve` / `plan/approve` methods — the exact
+requests any other client would make.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  ask-app-server (THE HOST — separate process)          │
+│  sessions · events · approvals · plan · tools          │
+└──────────────▲───────────────────────────┬─────────────┘
+               │ canonical protocol        │
+   ┌───────────┴──────────┐    ┌───────────▼─────────────┐
+   │  ask-terminal        │    │  web console · bots ·   │
+   │  (this client)       │    │  IDE — any client       │
+   └──────────────────────┘    └─────────────────────────┘
+```
+
+* `Client` — NDJSON protocol over the host's stdio or a unix socket;
+  request/response correlation, notification queue, connection-close
+  handling.
+* `Host` — spawns `ask-app-server` (`Gem.bin_path`) or connects to its
+  socket.
+* `Renderer` — canonical events → ANSI output (streaming deltas, tool
+  lifecycle, approvals, plans, todos).
+* `Repl` — the interactive loop: prompt → `session/send` → stream events
+  → resolve interactions inline → prompt again.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## License
+
+MIT

data/exe/ask

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "ask-terminal"
+
+exit Ask::Terminal::CLI.run!

data/exe/ask-terminal

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Long alias for `ask`. Both executables behave identically.
+require "ask-terminal"
+
+exit Ask::Terminal::CLI.run!

data/lib/ask/terminal/cli.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Ask
+  module Terminal
+    # Command-line entry for the terminal client. Installed as `ask`
+    # (primary) and `ask-terminal` (long alias).
+    #
+    #   ask                       spawn the host over stdio and attach
+    #   ask --socket PATH         attach to a running host
+    #   ask -w DIR --model M      options for session/create
+    class CLI
+      # The short command name (used in banners and help).
+      COMMAND_NAME = "ask"
+
+      def self.run!(args = ARGV)
+        new(args).run
+      end
+
+      def initialize(args)
+        @args = args.dup
+      end
+
+      def run
+        options = {
+          host: "stdio",
+          socket: nil,
+          workspace: Dir.pwd,
+          model: nil,
+          approval: "on_request"
+        }
+
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: #{COMMAND_NAME} [options]"
+          o.on("--host MODE", "stdio (spawn the host) or socket (attach) [stdio]") { |v| options[:host] = v }
+          o.on("--socket PATH", "Attach to a running host at PATH (implies --host socket)") { |v| options[:socket] = v }
+          o.on("-w", "--workspace DIR", "Workspace directory [current dir]") { |v| options[:workspace] = v }
+          o.on("--model MODEL", "Model identifier") { |v| options[:model] = v }
+          o.on("--approval MODE", "Approval mode: on_request | off | auto [on_request]") { |v| options[:approval] = v }
+          o.on("-h", "--help", "Show help") { puts o; return 0 }
+        end
+        parser.parse!(@args)
+
+        client =
+          if options[:socket] || options[:host] == "socket"
+            socket_path = options[:socket] || ENV["ASK_APP_SERVER_SOCKET"]
+            abort "a socket path is required (--socket PATH or ASK_APP_SERVER_SOCKET)" unless socket_path
+            Host.connect(socket_path)
+          else
+            spawned = Host.spawn
+            if spawned.socket_path
+              puts "host socket: #{spawned.socket_path}"
+              puts "attach with: ask --socket #{spawned.socket_path}"
+            end
+            spawned.client
+          end
+
+        repl = Repl.new(
+          client: client,
+          workspace: options[:workspace],
+          model: options[:model],
+          approval: options[:approval]
+        )
+        begin
+          repl.run
+        ensure
+          client.close
+        end
+        0
+      end
+    end
+  end
+end

data/lib/ask/terminal/client.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# The protocol client lives in ask-session-protocol; this constant is
+# kept as an alias so existing references keep working.
+require "ask-session-protocol"
+
+Ask::Terminal::Client = Ask::SessionProtocol::Client

data/lib/ask/terminal/host.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Host spawning/attach lives in ask-session-protocol; this constant is
+# kept as an alias so existing references keep working.
+require "ask-session-protocol"
+
+Ask::Terminal::Host = Ask::SessionProtocol::Host

data/lib/ask/terminal/renderer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module Terminal
+    # Renders canonical session events as ANSI terminal output. Accepts
+    # either a wire hash ({ "type" =>, "seq" =>, "payload" => }) or an
+    # Ask::SessionProtocol::Events::Event.
+    module Renderer
+      # ANSI helpers.
+      DIM = "\e[2m"
+      CYAN = "\e[36m"
+      YELLOW = "\e[33m"
+      GREEN = "\e[32m"
+      RED = "\e[31m"
+      MAGENTA = "\e[35m"
+      RESET = "\e[0m"
+
+      # How many lines of tool output to show inline.
+      MAX_OUTPUT_LINES = 20
+      MAX_ARG_CHARS = 120
+
+      # Render one event to `io`. Streaming deltas (model.streaming,
+      # tool.delta) print without a trailing newline; everything else
+      # prints a complete line.
+      #
+      # @param event [Hash, Ask::SessionProtocol::Events::Event]
+      # @param io [IO] output sink
+      def self.render(event, io: $stdout)
+        hash = event.respond_to?(:to_h) ? event.to_h : event
+        payload = hash["payload"] || {}
+
+        case hash["type"]
+        when "model.streaming"
+          io.print payload["delta"].to_s
+        when "model.thinking"
+          io.print "#{DIM}#{payload["delta"]}#{RESET}"
+        when "tool.use"
+          args = truncate(JSON.generate(payload["args"]))
+          io.puts "\n#{CYAN}› #{payload["name"]}#{args.empty? ? "" : " #{args}"}#{RESET}"
+        when "tool.delta"
+          io.print payload["partial"].to_s
+        when "tool.result"
+          render_tool_result(payload, io)
+        when "approval.required"
+          io.puts "#{YELLOW}✋ #{payload["toolName"]} requires approval (#{payload["id"]})#{RESET}"
+          io.puts "#{DIM}#{payload["message"]}#{RESET}" if payload["message"]
+        when "approval.updated"
+          mark = payload["status"] == "approved" ? "#{GREEN}✓#{RESET}" : "#{RED}✗#{RESET}"
+          io.puts "#{mark} #{payload["status"]} (#{payload["id"]})"
+        when "plan.proposed"
+          io.puts "\n#{MAGENTA}📋 Plan proposal (#{payload["id"]}):#{RESET}"
+          io.puts payload["plan"].to_s
+          io.puts "#{DIM}plan/approve or plan/reject to continue#{RESET}"
+        when "plan.approved"
+          io.puts "#{GREEN}✓ plan approved#{RESET}"
+        when "plan.rejected"
+          io.puts "#{RED}✗ plan rejected#{RESET}"
+        when "todos.updated"
+          render_todos(payload["todos"], io)
+        when "turn.started"
+          io.puts "#{DIM}── turn started ──#{RESET}"
+        when "turn.completed"
+          io.puts "\n#{DIM}── turn completed ──#{RESET}"
+        when "turn.failed"
+          io.puts "\n#{RED}✗ turn failed: #{payload["error"]}#{RESET}"
+        when "turn.aborted"
+          io.puts "\n#{DIM}── turn aborted ──#{RESET}"
+        when "error"
+          io.puts "#{RED}⚠ #{payload["error"]}#{RESET}"
+        when "session.created"
+          io.puts "#{DIM}session #{payload["sessionId"]} created#{RESET}"
+        when "session.ended"
+          io.puts "#{DIM}session #{payload["sessionId"]} ended (#{payload["reason"]})#{RESET}"
+        end
+        io.flush
+      end
+
+      def self.render_tool_result(payload, io)
+        output = payload["output"].to_s
+        if payload["isError"]
+          io.puts "#{RED}✗ #{payload["name"]} failed:#{RESET}"
+        else
+          io.puts "#{DIM}└ #{payload["name"]} (#{payload["durationMs"]}ms)#{RESET}" if payload["durationMs"]
+        end
+        return if output.empty?
+
+        lines = output.lines
+        lines.first(MAX_OUTPUT_LINES).each { |l| io.puts "#{DIM}  #{l.chomp}#{RESET}" }
+        io.puts "#{DIM}  … #{lines.size - MAX_OUTPUT_LINES} more lines#{RESET}" if lines.size > MAX_OUTPUT_LINES
+      end
+
+      def self.render_todos(todos, io)
+        return unless todos.is_a?(Array) && !todos.empty?
+
+        done = todos.count { |t| t["status"] == "completed" }
+        io.puts "#{DIM}todos: #{done}/#{todos.size} done#{RESET}"
+      end
+
+      def self.truncate(string)
+        string.to_s[0, MAX_ARG_CHARS]
+      end
+      private_class_method :truncate, :render_tool_result, :render_todos
+    end
+  end
+end

data/lib/ask/terminal/repl.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Ask
+  module Terminal
+    # The interactive terminal coding agent: a thin client of the session
+    # protocol. Owns one session with the host and drives it entirely
+    # through canonical requests and events:
+    #
+    #   prompt → session/send → stream events → turn ends → prompt again
+    #
+    # Human-in-the-loop events are handled inline: approvals ask y/n,
+    # plan proposals ask approve/reject, and both resolve through the
+    # canonical interaction/plan methods — the same requests any other
+    # client (web console, bot) would make.
+    class Repl
+      # @param client [Client] protocol client (spawned host or socket)
+      # @param input [IO] user input (readline when a tty, else gets)
+      # @param output [IO] rendered output
+      # @param workspace [String] workspace path for session/create
+      # @param model [String, nil] model override
+      # @param approval [String] approval mode: on_request | off | auto
+      def initialize(client:, input: $stdin, output: $stdout, workspace: Dir.pwd,
+                     model: nil, approval: "on_request")
+        @client = client
+        @input = input
+        @output = output
+        @workspace = workspace
+        @model = model
+        @approval = approval
+        @session_id = nil
+        @turn_active = false
+      end
+
+      # Connect to the host, create a session, and run the interactive loop.
+      # Returns when the user exits (/exit or EOF).
+      def run
+        handshake = @client.initialize!
+        @server_info = handshake["server"] || {}
+
+        created = @client.create_session(
+          workspace_path: @workspace, mode: @approval, model: @model
+        )
+        @session_id = created.dig("session", "sessionId")
+        @client.subscribe(@session_id, after_seq: 0)
+
+        banner
+        main_loop
+      rescue Client::ConnectionClosed
+        @output.puts "\n#{Renderer::RED}host closed the connection#{Renderer::RESET}"
+      end
+
+      private
+
+      def banner
+        @output.puts "#{Renderer::DIM}#{Ask::Terminal::CLI::COMMAND_NAME} #{Ask::Terminal::VERSION} · " \
+                     "protocol #{Ask::SessionProtocol::PROTOCOL_VERSION} · " \
+                     "host #{@server_info["name"]} #{@server_info["version"]}#{Renderer::RESET}"
+        @output.puts "#{Renderer::DIM}workspace: #{@workspace} · session: #{@session_id}#{Renderer::RESET}"
+        @output.puts "#{Renderer::DIM}type /help for commands#{Renderer::RESET}"
+      end
+
+      def main_loop
+        loop do
+          line = prompt
+          break if line.nil?
+
+          line = line.strip
+          next if line.empty?
+
+          if line.start_with?("/")
+            break if handle_command(line)
+          else
+            send_prompt(line)
+          end
+        end
+      end
+
+      def prompt
+        if @input.respond_to?(:tty?) && @input.tty?
+          require "readline"
+          Readline.readline("ask> ")
+        else
+          @output.print "ask> "
+          @output.flush
+          @input.gets
+        end
+      end
+
+      def send_prompt(content)
+        result = @client.send(@session_id, content)
+        case result["status"]
+        when "stale"
+          @output.puts "#{Renderer::YELLOW}message not accepted: turn moved on (stale)#{Renderer::RESET}"
+        when "queued"
+          @output.puts "#{Renderer::DIM}queued for the next turn boundary#{Renderer::RESET}"
+        end
+        wait_for_turn_end
+      end
+
+      # Drain notifications until the current turn ends. Approval and plan
+      # interactions are resolved inline; Ctrl-C aborts the turn.
+      def wait_for_turn_end
+        @turn_active = true
+        loop do
+          notification = @client.wait_notification(timeout: 0.2)
+          if notification.nil?
+            # No traffic this tick; keep waiting unless the turn already
+            # ended via an earlier event.
+            return unless @turn_active
+            next
+          end
+          return if notification == Client::CONNECTION_CLOSED
+
+          event = notification["params"] && notification["params"]["event"]
+          next unless event
+
+          Renderer.render(event, io: @output)
+          payload = event["payload"] || {}
+          case event["type"]
+          when "turn.completed", "turn.failed", "turn.aborted"
+            @turn_active = false
+            return
+          when "approval.required"
+            resolve_approval(payload)
+          when "plan.proposed"
+            resolve_plan(payload)
+          end
+        end
+      rescue Interrupt
+        @output.puts "\n#{Renderer::DIM}aborting turn…#{Renderer::RESET}"
+        @client.abort(@session_id) rescue nil
+        retry
+      ensure
+        @turn_active = false
+      end
+
+      def resolve_approval(payload)
+        @output.print "Approve #{payload["toolName"]} (#{payload["id"]})? [y/N] "
+        @output.flush
+        answer = @input.gets
+        if answer&.strip&.match?(/\Ay(es)?\z/i)
+          @client.approve(@session_id, payload["id"])
+        else
+          @client.reject(@session_id, payload["id"])
+        end
+      end
+
+      def resolve_plan(payload)
+        @output.print "Approve plan? [y/N] "
+        @output.flush
+        answer = @input.gets
+        if answer&.strip&.match?(/\Ay(es)?\z/i)
+          @client.plan_approve(@session_id)
+        else
+          @client.plan_reject(@session_id)
+        end
+      end
+
+      # ── Commands ────────────────────────────────────────────────────────
+
+      # @return [Boolean] true when the repl should exit
+      def handle_command(line)
+        command, *args = line.split(/\s+/)
+        case command
+        when "/exit", "/quit"
+          true
+        when "/help"
+          print_help
+        when "/approve"
+          args.empty? ? @client.approve_all(@session_id) : @client.approve(@session_id, args[0])
+          @output.puts "#{Renderer::GREEN}✓ approved#{Renderer::RESET}"
+        when "/reject"
+          args.empty? ? @client.reject_all(@session_id) : @client.reject(@session_id, args[0])
+          @output.puts "#{Renderer::RED}✗ rejected#{Renderer::RESET}"
+        when "/plan-approve"
+          @client.plan_approve(@session_id)
+        when "/plan-reject"
+          @client.plan_reject(@session_id)
+        when "/abort"
+          @client.abort(@session_id)
+          @output.puts "#{Renderer::DIM}abort sent#{Renderer::RESET}"
+        when "/status"
+          print_status
+        when "/sessions"
+          list = @client.request("session/list", {})
+          (list["sessions"] || []).each do |s|
+            @output.puts "#{s["sessionId"]}  #{s["model"]}  #{s["running"] ? "running" : "idle"}"
+          end
+        else
+          @output.puts "#{Renderer::YELLOW}unknown command: #{command} (try /help)#{Renderer::RESET}"
+        end
+        false
+      end
+
+      def print_help
+        @output.puts <<~HELP
+          #{Renderer::DIM}commands:#{Renderer::RESET}
+            /approve [id]      approve a pending approval (all when no id)
+            /reject [id]       reject a pending approval (all when no id)
+            /plan-approve      approve the pending plan proposal
+            /plan-reject       reject the pending plan proposal
+            /abort             abort the running turn
+            /status            show workspace and pending interactions
+            /sessions          list host sessions
+            /exit              quit
+        HELP
+      end
+
+      def print_status
+        state = @client.read_workspace_state(@session_id)
+        workspace = state["workspace"] || {}
+        @output.puts "#{Renderer::DIM}workspace: #{workspace["path"] || "—"} · " \
+                     "mode: #{workspace["mode"]}#{Renderer::RESET}"
+
+        interactions = @client.list_interactions(@session_id)
+        pending = interactions["interactions"] || []
+        if pending.empty?
+          @output.puts "#{Renderer::DIM}no pending approvals#{Renderer::RESET}"
+        else
+          pending.each do |i|
+            @output.puts "#{Renderer::YELLOW}✋ #{i["payload"]["toolName"]} (#{i["id"]})#{Renderer::RESET}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/terminal/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ask
+  module Terminal
+    VERSION = "0.2.1"
+  end
+end

data/lib/ask/terminal.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "ask-session-protocol"
+
+require_relative "terminal/version"
+require_relative "terminal/client"
+require_relative "terminal/host"
+require_relative "terminal/renderer"
+require_relative "terminal/repl"
+require_relative "terminal/cli"

data/lib/ask-terminal.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "ask/terminal"

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: ask-terminal
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Kaka Ruto
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ask-session-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: 'The first thin client of the ask ecosystem: an interactive terminal
+  coding agent that speaks the canonical ask-session-protocol and nothing else. Spawns
+  the host (ask-app-server) over stdio or attaches to a running host over its unix
+  socket — the same protocol any other client (web console, bots) speaks, so multiple
+  clients can share the same live sessions.'
+email:
+- kaka@myrrlabs.com
+executables:
+- ask
+- ask-terminal
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/ask
+- exe/ask-terminal
+- lib/ask-terminal.rb
+- lib/ask/terminal.rb
+- lib/ask/terminal/cli.rb
+- lib/ask/terminal/client.rb
+- lib/ask/terminal/host.rb
+- lib/ask/terminal/renderer.rb
+- lib/ask/terminal/repl.rb
+- lib/ask/terminal/version.rb
+homepage: https://github.com/ask-rb/ask-terminal
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.18
+specification_version: 4
+summary: Terminal client for the ask session protocol
+test_files: []