claude-office 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e027095a406422081e3db847e481224a96d6e2289983b66cec9076553c3d477
+  data.tar.gz: 98b602f6c16c80b79d146095500d2b38075685c6d7ed5e270a50bbcfea083ac0
+SHA512:
+  metadata.gz: 2f43f8f32940f07f81c368eadcea57c788ec956177571d3e31609e92583b8e85f1a7d15dfb7978a8f6aba6868a4f4061f672a265dd3903777a143ebd41f08ef0
+  data.tar.gz: c5fa2675865370aebd98520465677c616c858698464a00bc01191aa099bc37e2b6f8cae38b21b168e349996727590ce3475ca15baee6c2ea369bb27b4a5f8abb

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fernando Ruiz
+
+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/bin/claude-office

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/claude_office"
+require_relative "../lib/claude_office/cli"
+
+ClaudeOffice::CLI.run(ARGV)

data/lib/claude_office/agents/agent.rb

@@ -0,0 +1,78 @@
+require_relative "sub_agent"
+
+module ClaudeOffice
+  module Agents
+    class Agent
+      TOOL_ANIMATIONS = {
+        "Read" => :reading, "Glob" => :reading, "Grep" => :reading,
+        "WebFetch" => :reading, "WebSearch" => :reading,
+        "Edit" => :typing, "Write" => :typing, "NotebookEdit" => :typing,
+        "Bash" => :running,
+        "Task" => :typing,
+        "AskUserQuestion" => :waiting,
+        "EnterPlanMode" => :reading,
+      }.freeze
+
+      attr_reader :session_id, :state, :active_tools, :status_text,
+                  :animation, :desk_position, :sub_agents, :position
+
+      def initialize(session_id:, desk_position:)
+        @session_id = session_id
+        @desk_position = desk_position
+        @position = desk_position.dup
+        @state = :idle
+        @active_tools = {}
+        @status_text = ""
+        @animation = :idle
+        @sub_agents = {}
+      end
+
+      def tool_started(tool_id, tool_name, status_text)
+        @active_tools[tool_id] = tool_name
+        @status_text = status_text
+        @animation = TOOL_ANIMATIONS.fetch(tool_name, :idle)
+        @state = :working
+      end
+
+      def tool_done(tool_id)
+        tool_name = @active_tools.delete(tool_id)
+
+        if tool_name == "Task"
+          @sub_agents.delete(tool_id)
+        end
+
+        if @active_tools.empty?
+          @state = :idle
+          @animation = :idle
+          @status_text = ""
+        else
+          last_tool = @active_tools.values.last
+          @animation = TOOL_ANIMATIONS.fetch(last_tool, :idle)
+        end
+      end
+
+      def turn_ended
+        @state = :waiting
+        @animation = :waiting
+        @active_tools.clear
+        @sub_agents.clear
+        @status_text = ""
+      end
+
+      def new_turn
+        @state = :idle
+        @animation = :idle
+      end
+
+      def sub_agent_tool_started(parent_tool_id, tool_id, tool_name, status_text)
+        @sub_agents[parent_tool_id] ||= SubAgent.new(parent_tool_id: parent_tool_id)
+        @sub_agents[parent_tool_id].tool_started(tool_id, tool_name, status_text)
+      end
+
+      def sub_agent_tool_done(parent_tool_id, tool_id)
+        sub = @sub_agents[parent_tool_id]
+        sub&.tool_done(tool_id)
+      end
+    end
+  end
+end

data/lib/claude_office/agents/registry.rb

@@ -0,0 +1,35 @@
+require_relative "agent"
+
+module ClaudeOffice
+  module Agents
+    class Registry
+      attr_reader :agents
+
+      def initialize
+        @agents = {}
+      end
+
+      def add(session_id, desk_position)
+        agent = Agent.new(session_id: session_id, desk_position: desk_position)
+        @agents[session_id] = agent
+        agent
+      end
+
+      def get(session_id)
+        @agents[session_id]
+      end
+
+      def remove(session_id)
+        @agents.delete(session_id)
+      end
+
+      def count
+        @agents.size
+      end
+
+      def each(&block)
+        @agents.each_value(&block)
+      end
+    end
+  end
+end

data/lib/claude_office/agents/sub_agent.rb

@@ -0,0 +1,35 @@
+module ClaudeOffice
+  module Agents
+    class SubAgent
+      attr_reader :parent_tool_id, :active_tools, :status_text, :animation
+
+      TOOL_ANIMATIONS = {
+        "Read" => :reading, "Glob" => :reading, "Grep" => :reading,
+        "WebFetch" => :reading, "WebSearch" => :reading,
+        "Edit" => :typing, "Write" => :typing, "NotebookEdit" => :typing,
+        "Bash" => :running,
+      }.freeze
+
+      def initialize(parent_tool_id:)
+        @parent_tool_id = parent_tool_id
+        @active_tools = {}
+        @status_text = ""
+        @animation = :idle
+      end
+
+      def tool_started(tool_id, tool_name, status_text)
+        @active_tools[tool_id] = tool_name
+        @status_text = status_text
+        @animation = TOOL_ANIMATIONS.fetch(tool_name, :idle)
+      end
+
+      def tool_done(tool_id)
+        @active_tools.delete(tool_id)
+        if @active_tools.empty?
+          @animation = :idle
+          @status_text = ""
+        end
+      end
+    end
+  end
+end

data/lib/claude_office/animation/frame_cycle.rb

@@ -0,0 +1,22 @@
+module ClaudeOffice
+  module Animation
+    class FrameCycle
+      attr_reader :frame
+
+      def initialize(frame_count:, frames_per_tick: 10)
+        @frame_count = frame_count
+        @frames_per_tick = frames_per_tick
+        @tick = 0
+        @frame = 0
+      end
+
+      def advance
+        @tick += 1
+        if @tick >= @frames_per_tick
+          @tick = 0
+          @frame = (@frame + 1) % @frame_count
+        end
+      end
+    end
+  end
+end

data/lib/claude_office/animation/spring_mover.rb

@@ -0,0 +1,48 @@
+require "harmonica"
+
+module ClaudeOffice
+  module Animation
+    class SpringMover
+      def initialize(fps: 30)
+        @spring = Harmonica::Spring.new(
+          delta_time: Harmonica.fps(fps),
+          angular_frequency: 5.0,
+          damping_ratio: 0.8
+        )
+        @x = 0.0
+        @y = 0.0
+        @vx = 0.0
+        @vy = 0.0
+        @target_x = 0.0
+        @target_y = 0.0
+      end
+
+      def set_position(x, y)
+        @x = x.to_f
+        @y = y.to_f
+        @target_x = x.to_f
+        @target_y = y.to_f
+        @vx = 0.0
+        @vy = 0.0
+      end
+
+      def set_target(x, y)
+        @target_x = x.to_f
+        @target_y = y.to_f
+      end
+
+      def update
+        @x, @vx = @spring.update(@x, @vx, @target_x)
+        @y, @vy = @spring.update(@y, @vy, @target_y)
+      end
+
+      def position
+        [@x.round, @y.round]
+      end
+
+      def arrived?(threshold: 0.5)
+        (@x - @target_x).abs < threshold && (@y - @target_y).abs < threshold
+      end
+    end
+  end
+end

data/lib/claude_office/app.rb

@@ -0,0 +1,149 @@
+require "bubbletea"
+require "lipgloss"
+require_relative "transcript/watcher"
+require_relative "agents/registry"
+require_relative "office/grid"
+require_relative "office/pathfinder"
+require_relative "rendering/renderer"
+require_relative "animation/frame_cycle"
+require_relative "notification"
+
+module ClaudeOffice
+  class TickMessage < Bubbletea::Message; end
+
+  class App
+    include Bubbletea::Model
+
+    FPS = 30
+    GRID_WIDTH = 60
+    GRID_HEIGHT = 20
+
+    def initialize(project_dir:, sound: true)
+      @project_dir = project_dir
+      @sound = sound
+      @registry = Agents::Registry.new
+      @grid = Office::Grid.new(width: GRID_WIDTH, height: GRID_HEIGHT)
+      @pathfinder = Office::Pathfinder.new(@grid)
+      @renderer = Rendering::Renderer.new(width: GRID_WIDTH, height: GRID_HEIGHT)
+      @notification = Notification.new(sound_enabled: sound)
+      @frame_cycle = Animation::FrameCycle.new(frame_count: 2, frames_per_tick: 15)
+      @event_queue = Queue.new
+      @watcher = nil
+      @width = GRID_WIDTH
+      @height = GRID_HEIGHT
+    end
+
+    def init
+      @watcher = Transcript::Watcher.new(@project_dir, @event_queue)
+      @watcher.start
+
+      [self, schedule_tick]
+    end
+
+    def update(message)
+      case message
+      when Bubbletea::KeyMessage
+        handle_key(message)
+      when Bubbletea::WindowSizeMessage
+        @width = message.width
+        @height = message.height
+        grid_w = [@width, GRID_WIDTH].min
+        grid_h = [message.height - 4, GRID_HEIGHT].min
+        @grid = Office::Grid.new(width: grid_w, height: grid_h)
+        @grid.layout_for(@registry.count)
+        @pathfinder = Office::Pathfinder.new(@grid)
+        @renderer = Rendering::Renderer.new(width: @grid.width, height: @grid.height)
+        [self, nil]
+      when TickMessage
+        handle_tick
+      else
+        [self, nil]
+      end
+    end
+
+    def view
+      agents = []
+      @registry.each { |a| agents << a }
+      @renderer.render(grid: @grid, agents: agents, frame: @frame_cycle.frame)
+    end
+
+    private
+
+    def handle_key(message)
+      case message.to_s
+      when "q", "ctrl+c"
+        @watcher&.stop
+        [self, Bubbletea.quit]
+      else
+        [self, nil]
+      end
+    end
+
+    def handle_tick
+      while (event = @event_queue.pop(true) rescue nil)
+        process_event(event)
+      end
+
+      @frame_cycle.advance
+
+      [self, schedule_tick]
+    end
+
+    def process_event(event)
+      case event
+      when Transcript::AgentCreated
+        desk_pos = next_desk_position
+        @registry.add(event.session_id, desk_pos)
+        @grid.layout_for(@registry.count)
+        @pathfinder = Office::Pathfinder.new(@grid)
+        reassign_desk_positions
+
+      when Transcript::ToolStart
+        agent = @registry.get(event.session_id)
+        agent&.tool_started(event.tool_id, event.tool_name, event.status_text)
+
+      when Transcript::ToolDone
+        agent = @registry.get(event.session_id)
+        agent&.tool_done(event.tool_id)
+
+      when Transcript::TurnEnd
+        agent = @registry.get(event.session_id)
+        if agent
+          agent.turn_ended
+          @notification.agent_turn_ended(event.session_id)
+        end
+
+      when Transcript::SubAgentToolStart
+        agent = @registry.get(event.session_id)
+        agent&.sub_agent_tool_started(
+          event.parent_tool_id, event.tool_id,
+          event.tool_name, event.status_text
+        )
+
+      when Transcript::SubAgentToolDone
+        agent = @registry.get(event.session_id)
+        agent&.sub_agent_tool_done(event.parent_tool_id, event.tool_id)
+      end
+    end
+
+    def next_desk_position
+      count = @registry.count
+      [3 + (count % 3) * 13, 3 + (count / 3) * 7]
+    end
+
+    def reassign_desk_positions
+      index = 0
+      @registry.each do |agent|
+        if index < @grid.desks.length
+          desk = @grid.desks[index]
+          desk.assign(agent.session_id)
+        end
+        index += 1
+      end
+    end
+
+    def schedule_tick
+      Bubbletea.tick(1.0 / FPS) { TickMessage.new }
+    end
+  end
+end

data/lib/claude_office/cli.rb

@@ -0,0 +1,47 @@
+require_relative "transcript/watcher"
+
+module ClaudeOffice
+  class CLI
+    def self.run(args)
+      if args.include?("--version")
+        puts "claude-office #{ClaudeOffice::VERSION}"
+        return
+      end
+
+      if args.include?("--help")
+        puts <<~HELP
+          Usage: claude-office [PROJECT_PATH] [OPTIONS]
+
+          Watch Claude Code sessions as animated characters in a terminal office.
+
+          Arguments:
+            PROJECT_PATH    Path to project (default: current directory)
+
+          Options:
+            --no-sound      Disable terminal bell notifications
+            --version       Show version
+            --help          Show this help
+        HELP
+        return
+      end
+
+      project_path = args.reject { |a| a.start_with?("--") }.first || Dir.pwd
+      sound = !args.include?("--no-sound")
+
+      project_dir = Transcript::Watcher.claude_project_dir(project_path)
+
+      unless Dir.exist?(project_dir)
+        $stderr.puts "Error: No Claude Code data found for #{project_path}"
+        $stderr.puts "Expected: #{project_dir}"
+        $stderr.puts ""
+        $stderr.puts "Make sure you've run Claude Code in that directory at least once."
+        exit 1
+      end
+
+      require_relative "app"
+
+      app = App.new(project_dir: project_dir, sound: sound)
+      Bubbletea.run(app, alt_screen: true, mouse_cell_motion: true)
+    end
+  end
+end

data/lib/claude_office/notification.rb

@@ -0,0 +1,22 @@
+module ClaudeOffice
+  class Notification
+    def initialize(sound_enabled: true)
+      @sound_enabled = sound_enabled
+    end
+
+    def agent_waiting(session_id)
+      bell if @sound_enabled
+    end
+
+    def agent_turn_ended(session_id)
+      bell if @sound_enabled
+    end
+
+    private
+
+    def bell
+      print "\a"
+      $stdout.flush
+    end
+  end
+end

data/lib/claude_office/office/desk.rb

@@ -0,0 +1,25 @@
+module ClaudeOffice
+  module Office
+    class Desk
+      attr_reader :position, :chair_position, :assigned_session_id
+
+      def initialize(position:, chair_position:)
+        @position = position
+        @chair_position = chair_position
+        @assigned_session_id = nil
+      end
+
+      def assign(session_id)
+        @assigned_session_id = session_id
+      end
+
+      def unassign
+        @assigned_session_id = nil
+      end
+
+      def assigned?
+        !@assigned_session_id.nil?
+      end
+    end
+  end
+end

data/lib/claude_office/office/grid.rb

@@ -0,0 +1,66 @@
+require_relative "desk"
+
+module ClaudeOffice
+  module Office
+    class Grid
+      DESKS_PER_ROW = 3
+      DESK_WIDTH = 7
+      DESK_HEIGHT = 3
+      DESK_SPACING_X = 6
+      DESK_SPACING_Y = 7
+      MARGIN_X = 3
+      MARGIN_Y = 2
+
+      attr_reader :width, :height, :desks, :tiles
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+        @desks = []
+        @tiles = Array.new(height) { Array.new(width, :floor) }
+        place_walls
+      end
+
+      def layout_for(agent_count)
+        @desks.clear
+        return if agent_count == 0
+
+        rows = (agent_count.to_f / DESKS_PER_ROW).ceil
+        agent_index = 0
+
+        rows.times do |row|
+          desks_in_row = [DESKS_PER_ROW, agent_count - agent_index].min
+          row_y = MARGIN_Y + 1 + row * DESK_SPACING_Y
+
+          desks_in_row.times do |col|
+            desk_x = MARGIN_X + 1 + col * (DESK_WIDTH + DESK_SPACING_X)
+            desk_pos = [desk_x, row_y]
+            chair_pos = [desk_x + DESK_WIDTH / 2, row_y + DESK_HEIGHT + 1]
+
+            @desks << Desk.new(position: desk_pos, chair_position: chair_pos)
+            agent_index += 1
+          end
+        end
+      end
+
+      def walkable?(x, y)
+        return false if x < 0 || y < 0 || x >= @width || y >= @height
+
+        @tiles[y][x] == :floor
+      end
+
+      private
+
+      def place_walls
+        @width.times do |x|
+          @tiles[0][x] = :wall
+          @tiles[@height - 1][x] = :wall
+        end
+        @height.times do |y|
+          @tiles[y][0] = :wall
+          @tiles[y][@width - 1] = :wall
+        end
+      end
+    end
+  end
+end

data/lib/claude_office/office/pathfinder.rb

@@ -0,0 +1,53 @@
+module ClaudeOffice
+  module Office
+    class Pathfinder
+      DIRECTIONS = [[0, -1], [0, 1], [-1, 0], [1, 0]].freeze
+
+      def initialize(grid)
+        @grid = grid
+      end
+
+      def find_path(start, goal)
+        return [start] if start == goal
+        return nil unless @grid.walkable?(start[0], start[1])
+        return nil unless @grid.walkable?(goal[0], goal[1])
+
+        queue = [start]
+        came_from = { start => nil }
+
+        until queue.empty?
+          current = queue.shift
+
+          if current == goal
+            return reconstruct_path(came_from, goal)
+          end
+
+          DIRECTIONS.each do |dx, dy|
+            neighbor = [current[0] + dx, current[1] + dy]
+            next if came_from.key?(neighbor)
+            next unless @grid.walkable?(neighbor[0], neighbor[1])
+
+            came_from[neighbor] = current
+            queue << neighbor
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def reconstruct_path(came_from, goal)
+        path = [goal]
+        current = goal
+
+        while came_from[current]
+          current = came_from[current]
+          path.unshift(current)
+        end
+
+        path
+      end
+    end
+  end
+end

data/lib/claude_office/rendering/renderer.rb

@@ -0,0 +1,122 @@
+require "lipgloss"
+require_relative "sprites"
+require_relative "theme"
+
+module ClaudeOffice
+  module Rendering
+    class Renderer
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      def render(grid:, agents:, frame:)
+        title = render_title(grid)
+        office = render_office(grid, agents, frame)
+        status = render_status_bar(agents)
+
+        Lipgloss.join_vertical(:left, title, office, status)
+      end
+
+      private
+
+      def render_title(grid)
+        Theme::TITLE_STYLE
+          .width(@width)
+          .render("claude-office")
+      end
+
+      def render_office(grid, agents, frame)
+        lines = []
+
+        grid.height.times do |y|
+          line = ""
+          grid.width.times do |x|
+            case grid.tiles[y][x]
+            when :wall
+              line += Theme::WALL_STYLE.render(Sprites::WALL_CHAR)
+            else
+              line += Theme::FLOOR_STYLE.render(Sprites::FLOOR_CHAR)
+            end
+          end
+          lines << line
+        end
+
+        office_str = lines.join("\n")
+
+        grid.desks.each do |desk|
+          desk_str = Sprites::DESK.map { |row| Theme::DESK_STYLE.render(row) }.join("\n")
+          office_str = overlay(office_str, desk_str, desk.position[0], desk.position[1])
+        end
+
+        agents.each do |agent|
+          face = Sprites.face_for(agent.animation, frame: frame)
+          style = Theme.agent_style(agent.state)
+          agent_str = style.render(face)
+
+          unless agent.status_text.empty?
+            status = Theme::STATUS_TEXT_STYLE.render("\"#{agent.status_text}\"")
+            agent_str = Lipgloss.join_vertical(:center, agent_str, status)
+          end
+
+          agent.sub_agents.each_value do |sub|
+            sub_face = Sprites.sub_face_for(sub.animation)
+            sub_line = Theme::SUB_AGENT_STYLE.render("└─ #{sub_face}")
+            unless sub.status_text.empty?
+              sub_line += " " + Theme::STATUS_TEXT_STYLE.render("\"#{sub.status_text}\"")
+            end
+            agent_str = Lipgloss.join_vertical(:left, agent_str, sub_line)
+          end
+
+          if agent.state == :waiting
+            bubble = Theme::SPEECH_BUBBLE_STYLE.render("Needs input!")
+            agent_str = Lipgloss.join_vertical(:center, bubble, agent_str)
+          end
+
+          pos = agent.desk_position
+          char_x = pos[0] + 1
+          char_y = pos[1] + Sprites::DESK.length + 1
+          office_str = overlay(office_str, agent_str, char_x, char_y)
+        end
+
+        office_str
+      end
+
+      def render_status_bar(agents)
+        parts = agents.map do |agent|
+          state_str = agent.state.to_s
+          subs = agent.sub_agents.size
+          sub_info = subs > 0 ? " (#{subs} sub#{"s" if subs > 1})" : ""
+          "Agent: #{state_str}#{sub_info}"
+        end
+
+        parts << "q: quit"
+        bar_text = parts.join(" │ ")
+
+        Theme::STATUS_BAR_STYLE
+          .width(@width)
+          .render(bar_text)
+      end
+
+      def overlay(base, overlay_str, x, y)
+        base_lines = base.split("\n")
+        overlay_lines = overlay_str.split("\n")
+
+        overlay_lines.each_with_index do |oline, i|
+          target_y = y + i
+          next if target_y < 0 || target_y >= base_lines.length
+
+          base_line = base_lines[target_y]
+          visible_len = Lipgloss.width(oline)
+
+          before = base_line[0...x] || ""
+          after_start = x + visible_len
+          after = base_line[after_start..] || ""
+          base_lines[target_y] = before + oline + after
+        end
+
+        base_lines.join("\n")
+      end
+    end
+  end
+end

data/lib/claude_office/rendering/sprites.rb

@@ -0,0 +1,40 @@
+module ClaudeOffice
+  module Rendering
+    module Sprites
+      FACES = {
+        idle:     "(o_o)",
+        typing:   "(o.o)~",
+        reading:  "(o.O)",
+        running:  "(>.<)",
+        waiting:  "(-.-)zzZ",
+        walking:  ["(o_o)/", "(o_o)\\"],
+      }.freeze
+
+      SUB_AGENT_FACES = {
+        idle:    "(o_o)",
+        typing:  "(o.o)",
+        reading: "(o.O)",
+        running: "(>.<)",
+        waiting: "(-.-)",
+      }.freeze
+
+      DESK = [
+        "┌─────┐",
+        "│ ▒▒▒ │",
+        "└──┬──┘",
+      ].freeze
+
+      FLOOR_CHAR = "░"
+      WALL_CHAR = "█"
+
+      def self.face_for(animation, frame: 0)
+        sprite = FACES.fetch(animation, FACES[:idle])
+        sprite.is_a?(Array) ? sprite[frame % sprite.length] : sprite
+      end
+
+      def self.sub_face_for(animation)
+        SUB_AGENT_FACES.fetch(animation, SUB_AGENT_FACES[:idle])
+      end
+    end
+  end
+end

data/lib/claude_office/rendering/theme.rb

@@ -0,0 +1,59 @@
+require "lipgloss"
+
+module ClaudeOffice
+  module Rendering
+    module Theme
+      FLOOR_STYLE = Lipgloss::Style.new
+        .foreground("#555555")
+        .background("#2D2D2D")
+
+      WALL_STYLE = Lipgloss::Style.new
+        .foreground("#777777")
+        .background("#444444")
+
+      DESK_STYLE = Lipgloss::Style.new
+        .foreground("#8B6914")
+
+      ACTIVE_AGENT_STYLE = Lipgloss::Style.new
+        .foreground("#00D4AA")
+        .bold(true)
+
+      WAITING_AGENT_STYLE = Lipgloss::Style.new
+        .foreground("#FFD700")
+
+      IDLE_AGENT_STYLE = Lipgloss::Style.new
+        .foreground("#AAAAAA")
+
+      STATUS_TEXT_STYLE = Lipgloss::Style.new
+        .foreground("#888888")
+        .italic(true)
+
+      SUB_AGENT_STYLE = Lipgloss::Style.new
+        .foreground("#77AADD")
+
+      SPEECH_BUBBLE_STYLE = Lipgloss::Style.new
+        .border(:rounded)
+        .border_foreground("#874BFD")
+        .padding(0, 1)
+
+      TITLE_STYLE = Lipgloss::Style.new
+        .bold(true)
+        .foreground("#FFFFFF")
+        .background("#333333")
+        .padding(0, 1)
+
+      STATUS_BAR_STYLE = Lipgloss::Style.new
+        .foreground("#CCCCCC")
+        .background("#333333")
+        .padding(0, 1)
+
+      def self.agent_style(state)
+        case state
+        when :working then ACTIVE_AGENT_STYLE
+        when :waiting then WAITING_AGENT_STYLE
+        else IDLE_AGENT_STYLE
+        end
+      end
+    end
+  end
+end

data/lib/claude_office/transcript/events.rb

@@ -0,0 +1,71 @@
+module ClaudeOffice
+  module Transcript
+    class AgentCreated
+      attr_reader :session_id, :jsonl_path
+
+      def initialize(session_id:, jsonl_path:)
+        @session_id = session_id
+        @jsonl_path = jsonl_path
+      end
+    end
+
+    class ToolStart
+      attr_reader :session_id, :tool_id, :tool_name, :status_text
+
+      def initialize(session_id:, tool_id:, tool_name:, status_text:)
+        @session_id = session_id
+        @tool_id = tool_id
+        @tool_name = tool_name
+        @status_text = status_text
+      end
+    end
+
+    class ToolDone
+      attr_reader :session_id, :tool_id
+
+      def initialize(session_id:, tool_id:)
+        @session_id = session_id
+        @tool_id = tool_id
+      end
+    end
+
+    class TurnEnd
+      attr_reader :session_id, :duration_ms
+
+      def initialize(session_id:, duration_ms:)
+        @session_id = session_id
+        @duration_ms = duration_ms
+      end
+    end
+
+    class SubAgentToolStart
+      attr_reader :session_id, :parent_tool_id, :tool_id, :tool_name, :status_text
+
+      def initialize(session_id:, parent_tool_id:, tool_id:, tool_name:, status_text:)
+        @session_id = session_id
+        @parent_tool_id = parent_tool_id
+        @tool_id = tool_id
+        @tool_name = tool_name
+        @status_text = status_text
+      end
+    end
+
+    class SubAgentToolDone
+      attr_reader :session_id, :parent_tool_id, :tool_id
+
+      def initialize(session_id:, parent_tool_id:, tool_id:)
+        @session_id = session_id
+        @parent_tool_id = parent_tool_id
+        @tool_id = tool_id
+      end
+    end
+
+    class TextOnly
+      attr_reader :session_id
+
+      def initialize(session_id:)
+        @session_id = session_id
+      end
+    end
+  end
+end

data/lib/claude_office/transcript/parser.rb

@@ -0,0 +1,183 @@
+require "json"
+require_relative "events"
+
+module ClaudeOffice
+  module Transcript
+    class Parser
+      BASH_COMMAND_MAX_LENGTH = 40
+      TASK_DESCRIPTION_MAX_LENGTH = 40
+
+      def initialize(session_id)
+        @session_id = session_id
+        @active_tools = {}
+      end
+
+      def register_active_tool(tool_id, tool_name)
+        @active_tools[tool_id] = tool_name
+      end
+
+      def unregister_active_tool(tool_id)
+        @active_tools.delete(tool_id)
+      end
+
+      def parse_line(line)
+        record = JSON.parse(line)
+        type = record["type"]
+
+        case type
+        when "assistant"
+          parse_assistant(record)
+        when "user"
+          parse_user(record)
+        when "system"
+          parse_system(record)
+        when "progress"
+          parse_progress(record)
+        else
+          []
+        end
+      rescue JSON::ParserError
+        []
+      end
+
+      private
+
+      def parse_assistant(record)
+        content = record.dig("message", "content")
+        return [] unless content.is_a?(Array)
+
+        tool_uses = content.select { |b| b["type"] == "tool_use" }
+
+        if tool_uses.any?
+          tool_uses.map do |block|
+            tool_name = block["name"] || ""
+            input = block["input"] || {}
+            status = format_tool_status(tool_name, input)
+
+            register_active_tool(block["id"], tool_name)
+
+            ToolStart.new(
+              session_id: @session_id,
+              tool_id: block["id"],
+              tool_name: tool_name,
+              status_text: status
+            )
+          end
+        elsif content.any? { |b| b["type"] == "text" }
+          [TextOnly.new(session_id: @session_id)]
+        else
+          []
+        end
+      end
+
+      def parse_user(record)
+        content = record.dig("message", "content")
+
+        if content.is_a?(Array)
+          tool_results = content.select { |b| b["type"] == "tool_result" }
+
+          tool_results.map do |block|
+            tool_id = block["tool_use_id"]
+            unregister_active_tool(tool_id)
+            ToolDone.new(session_id: @session_id, tool_id: tool_id)
+          end
+        else
+          []
+        end
+      end
+
+      def parse_system(record)
+        return [] unless record["subtype"] == "turn_duration"
+
+        [TurnEnd.new(
+          session_id: @session_id,
+          duration_ms: record["durationMs"]
+        )]
+      end
+
+      def parse_progress(record)
+        parent_tool_id = record["parentToolUseID"]
+        return [] unless parent_tool_id
+        return [] unless @active_tools[parent_tool_id] == "Task"
+
+        data = record["data"]
+        return [] unless data.is_a?(Hash)
+
+        message = data.dig("message")
+        return [] unless message.is_a?(Hash)
+
+        msg_type = message["type"]
+        inner_content = message.dig("message", "content")
+        return [] unless inner_content.is_a?(Array)
+
+        case msg_type
+        when "assistant"
+          inner_content.select { |b| b["type"] == "tool_use" }.map do |block|
+            tool_name = block["name"] || ""
+            input = block["input"] || {}
+            status = format_tool_status(tool_name, input)
+
+            SubAgentToolStart.new(
+              session_id: @session_id,
+              parent_tool_id: parent_tool_id,
+              tool_id: block["id"],
+              tool_name: tool_name,
+              status_text: status
+            )
+          end
+        when "user"
+          inner_content.select { |b| b["type"] == "tool_result" }.map do |block|
+            SubAgentToolDone.new(
+              session_id: @session_id,
+              parent_tool_id: parent_tool_id,
+              tool_id: block["tool_use_id"]
+            )
+          end
+        else
+          []
+        end
+      end
+
+      def format_tool_status(tool_name, input)
+        case tool_name
+        when "Read"
+          "Reading #{basename(input["file_path"])}"
+        when "Edit"
+          "Editing #{basename(input["file_path"])}"
+        when "Write"
+          "Writing #{basename(input["file_path"])}"
+        when "Bash"
+          cmd = (input["command"] || "").to_s
+          truncated = cmd.length > BASH_COMMAND_MAX_LENGTH ? "#{cmd[0...BASH_COMMAND_MAX_LENGTH]}…" : cmd
+          "Running: #{truncated}"
+        when "Glob"
+          "Searching files"
+        when "Grep"
+          "Searching code"
+        when "WebFetch"
+          "Fetching web content"
+        when "WebSearch"
+          "Searching the web"
+        when "Task"
+          desc = (input["description"] || "").to_s
+          truncated = desc.length > TASK_DESCRIPTION_MAX_LENGTH ? "#{desc[0...TASK_DESCRIPTION_MAX_LENGTH]}…" : desc
+          truncated.empty? ? "Running subtask" : "Subtask: #{truncated}"
+        when "AskUserQuestion"
+          "Waiting for your answer"
+        when "EnterPlanMode"
+          "Planning"
+        when "NotebookEdit"
+          "Editing notebook"
+        else
+          "Using #{tool_name}"
+        end
+      end
+
+      def basename(path)
+        return "" unless path.is_a?(String)
+
+        File.basename(path)
+      end
+    end
+  end
+end

data/lib/claude_office/transcript/watcher.rb

@@ -0,0 +1,99 @@
+require_relative "parser"
+require_relative "events"
+
+module ClaudeOffice
+  module Transcript
+    class Watcher
+      POLL_INTERVAL = 2.0
+
+      attr_reader :project_dir
+
+      def initialize(project_dir, event_queue)
+        @project_dir = project_dir
+        @event_queue = event_queue
+        @known_files = {}
+        @running = false
+        @thread = nil
+      end
+
+      def self.project_slug(path)
+        path.gsub("/", "-")
+      end
+
+      def self.claude_project_dir(project_path)
+        slug = project_slug(File.expand_path(project_path))
+        File.join(Dir.home, ".claude", "projects", slug)
+      end
+
+      def start
+        @running = true
+        @thread = Thread.new { run_loop }
+        @thread.abort_on_exception = true
+      end
+
+      def stop
+        @running = false
+        @thread&.join(2)
+      end
+
+      def scan_once
+        return unless Dir.exist?(@project_dir)
+
+        Dir.glob(File.join(@project_dir, "*.jsonl")).each do |path|
+          next if @known_files.key?(path)
+
+          session_id = File.basename(path, ".jsonl")
+          parser = Parser.new(session_id)
+
+          @known_files[path] = {
+            parser: parser,
+            offset: 0,
+            line_buffer: ""
+          }
+
+          @event_queue.push(AgentCreated.new(
+            session_id: session_id,
+            jsonl_path: path
+          ))
+        end
+      end
+
+      def read_new_lines
+        @known_files.each do |path, state|
+          read_file_lines(path, state)
+        end
+      end
+
+      private
+
+      def run_loop
+        while @running
+          scan_once
+          read_new_lines
+          sleep(POLL_INTERVAL)
+        end
+      end
+
+      def read_file_lines(path, state)
+        return unless File.exist?(path)
+
+        size = File.size(path)
+        return if size <= state[:offset]
+
+        data = File.binread(path, size - state[:offset], state[:offset])
+        state[:offset] = size
+
+        text = state[:line_buffer] + data.force_encoding("UTF-8")
+        lines = text.split("\n", -1)
+        state[:line_buffer] = lines.pop || ""
+
+        lines.each do |line|
+          next if line.strip.empty?
+
+          events = state[:parser].parse_line(line)
+          events.each { |e| @event_queue.push(e) }
+        end
+      end
+    end
+  end
+end

data/lib/claude_office/version.rb

@@ -0,0 +1,3 @@
+module ClaudeOffice
+  VERSION = "0.1.0"
+end

data/lib/claude_office.rb

@@ -0,0 +1,19 @@
+require_relative "claude_office/version"
+require_relative "claude_office/transcript/events"
+require_relative "claude_office/transcript/parser"
+require_relative "claude_office/transcript/watcher"
+require_relative "claude_office/agents/agent"
+require_relative "claude_office/agents/sub_agent"
+require_relative "claude_office/agents/registry"
+require_relative "claude_office/office/desk"
+require_relative "claude_office/office/grid"
+require_relative "claude_office/office/pathfinder"
+require_relative "claude_office/rendering/sprites"
+require_relative "claude_office/rendering/theme"
+require_relative "claude_office/rendering/renderer"
+require_relative "claude_office/animation/spring_mover"
+require_relative "claude_office/animation/frame_cycle"
+require_relative "claude_office/notification"
+
+module ClaudeOffice
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: claude-office
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fernando Ruiz
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bubbletea
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: lipgloss
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: harmonica
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !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'
+description: Watch Claude Code sessions come alive as kaomoji characters in a terminal
+  office. Characters walk, type, read, and wait based on real-time JSONL transcript
+  data.
+email:
+- fruizg0302@users.noreply.github.com
+executables:
+- claude-office
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/claude-office
+- lib/claude_office.rb
+- lib/claude_office/agents/agent.rb
+- lib/claude_office/agents/registry.rb
+- lib/claude_office/agents/sub_agent.rb
+- lib/claude_office/animation/frame_cycle.rb
+- lib/claude_office/animation/spring_mover.rb
+- lib/claude_office/app.rb
+- lib/claude_office/cli.rb
+- lib/claude_office/notification.rb
+- lib/claude_office/office/desk.rb
+- lib/claude_office/office/grid.rb
+- lib/claude_office/office/pathfinder.rb
+- lib/claude_office/rendering/renderer.rb
+- lib/claude_office/rendering/sprites.rb
+- lib/claude_office/rendering/theme.rb
+- lib/claude_office/transcript/events.rb
+- lib/claude_office/transcript/parser.rb
+- lib/claude_office/transcript/watcher.rb
+- lib/claude_office/version.rb
+homepage: https://github.com/fruizg0302/claude-office
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fruizg0302/claude-office
+  source_code_uri: https://github.com/fruizg0302/claude-office
+  changelog_uri: https://github.com/fruizg0302/claude-office/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: A TUI companion for Claude Code — animated kaomoji agents in a virtual office
+test_files: []