writers_room 0.0.1

data/lib/writers_room/config.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module WritersRoom
+  class Config
+    attr_reader :path, :data
+
+    DEFAULT_CONFIG = {
+      "provider" => "ollama",
+      "model_name" => "gpt-oss",
+    }.freeze
+
+    def initialize(path = nil)
+      @path = path || default_config_path
+      @data = load_config
+    end
+
+    # Load configuration from file
+    #
+    # @return [Hash] configuration data
+    def load_config
+      return DEFAULT_CONFIG.dup unless File.exist?(path)
+
+      YAML.load_file(path) || DEFAULT_CONFIG.dup
+    rescue StandardError => e
+      warn "Error loading config from #{path}: #{e.message}"
+      DEFAULT_CONFIG.dup
+    end
+
+    # Save configuration to file
+    #
+    # @param config_data [Hash] configuration data to save
+    # @return [Boolean] true if successful
+    def save(config_data = @data)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, YAML.dump(config_data))
+      @data = config_data
+      true
+    rescue StandardError => e
+      warn "Error saving config to #{path}: #{e.message}"
+      false
+    end
+
+    # Create a new project configuration
+    #
+    # @param project_path [String] path to project directory
+    # @param options [Hash] configuration options
+    # @return [WritersRoom::Config] new config instance
+    def self.create_project(project_path, options = {})
+      FileUtils.mkdir_p(project_path)
+
+      config_path = File.join(project_path, "config.yml")
+      config_data = DEFAULT_CONFIG.merge(options.transform_keys(&:to_s))
+
+      config = new(config_path)
+      config.save(config_data)
+      config
+    end
+
+    # Get configuration value
+    #
+    # @param key [String, Symbol] configuration key
+    # @return [Object] configuration value
+    def get(key)
+      @data[key.to_s]
+    end
+
+    # Set configuration value
+    #
+    # @param key [String, Symbol] configuration key
+    # @param value [Object] configuration value
+    def set(key, value)
+      @data[key.to_s] = value
+    end
+
+    # Get provider
+    #
+    # @return [String] LLM provider name
+    def provider
+      get("provider")
+    end
+
+    # Get model name
+    #
+    # @return [String] model name
+    def model_name
+      get("model_name")
+    end
+
+    private
+
+    def default_config_path
+      File.join(Dir.pwd, "config.yml")
+    end
+  end
+end

data/lib/writers_room/director.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+##########################################################
+###
+##  File: director.rb
+##  Desc: Director to orchestrate multiple actors in a scene
+##  By:   Dewayne VanHoozer (dvanhoozer@gmail.com)
+#
+
+require "debug_me"
+include DebugMe
+
+require "yaml"
+require "redis"
+require "smart_message"
+
+# Load message classes
+require_relative "messages/dialog_message"
+require_relative "messages/scene_control_message"
+require_relative "messages/stage_direction_message"
+require_relative "messages/meta_message"
+
+module WritersRoom
+  class Director
+    attr_reader :scene_info, :actor_processes, :transcript
+
+    # Initialize the Director
+    #
+    # @param scene_file [String] Path to scene YAML file
+    # @param character_dir [String] Directory containing character YAML files (optional, auto-detected)
+    def initialize(scene_file:, character_dir: nil)
+      @scene_file = scene_file
+      @character_dir = character_dir || detect_character_dir(scene_file)
+      @scene_info = load_scene
+      @actor_processes = []
+      @transcript = []
+      @running = false
+      @redis = Redis.new
+
+      debug_me("Director initialized") {
+        [@scene_info[:scene_name], @scene_info[:characters].join(", "), @character_dir]
+      }
+    end
+
+    # Start the scene with all actors
+    def action!
+      puts "\n" + "=" * 60
+      puts "SCENE #{@scene_info[:scene_number]}: #{@scene_info[:scene_name]}"
+      puts "Location: #{@scene_info[:location]}"
+      puts "Characters: #{@scene_info[:characters].join(", ")}"
+      puts "=" * 60 + "\n"
+
+      @running = true
+
+      # Start all actor processes
+      start_actors
+
+      # Send start scene control message
+      send_control_message("start")
+
+      # Listen to dialog and manage the scene
+      monitor_scene
+
+      # Cleanup
+      stop_actors
+    end
+
+    # Stop the scene and all actors
+    def cut!
+      @running = false
+      send_control_message("stop")
+      puts "\n[DIRECTOR: CUT! Scene ended.]"
+    end
+
+    # Save the transcript to a file
+    #
+    # @param filename [String] Output filename
+    def save_transcript(filename = nil)
+      filename ||= "transcript_scene_#{@scene_info[:scene_number]}_#{Time.now.to_i}.txt"
+
+      File.open(filename, "w") do |file|
+        file.puts "SCENE #{@scene_info[:scene_number]}: #{@scene_info[:scene_name]}"
+        file.puts "Location: #{@scene_info[:location]}"
+        file.puts "Week: #{@scene_info[:week]}"
+        file.puts "\n" + "-" * 60 + "\n"
+
+        @transcript.each do |entry|
+          case entry[:type]
+          when :dialog
+            file.puts "#{entry[:character]}: #{entry[:line]}"
+          when :stage_direction
+            file.puts "[#{entry[:character].upcase} #{entry[:action]}]"
+          when :beat
+            file.puts "\n--- #{entry[:content]} ---\n"
+          end
+        end
+      end
+
+      puts "Transcript saved to: #{filename}"
+      filename
+    end
+
+    # Get scene statistics
+    def statistics
+      total_lines = @transcript.count { |e| e[:type] == :dialog }
+      lines_by_character = @transcript
+        .select { |e| e[:type] == :dialog }
+        .group_by { |e| e[:character] }
+        .transform_values(&:count)
+
+      {
+        total_lines: total_lines,
+        lines_by_character: lines_by_character,
+        duration: @transcript.last&.dig(:timestamp).to_i - @transcript.first&.dig(:timestamp).to_i,
+        scene: @scene_info[:scene_number],
+      }
+    end
+
+    private
+
+    # Auto-detect character directory from scene file path
+    # If scene is in projects/PROJECT_NAME/scenes/, look for projects/PROJECT_NAME/characters/
+    # Otherwise fall back to 'characters' in current directory
+    def detect_character_dir(scene_file)
+      scene_path = File.expand_path(scene_file)
+      scene_dir = File.dirname(scene_path)
+
+      # Check if scene is in a project structure (projects/PROJECT_NAME/scenes/)
+      if scene_dir =~ %r{projects/([^/]+)/scenes}
+        project_name = $1
+        character_dir = File.join("projects", project_name, "characters")
+
+        if Dir.exist?(character_dir)
+          debug_me("Auto-detected character directory") { character_dir }
+          return character_dir
+        end
+      end
+
+      # Fall back to looking for 'characters' relative to scene directory
+      character_dir = File.join(scene_dir, "..", "characters")
+      if Dir.exist?(character_dir)
+        debug_me("Found character directory relative to scene") { character_dir }
+        return File.expand_path(character_dir)
+      end
+
+      # Final fallback
+      debug_me("Using default character directory") { "characters" }
+      "characters"
+    end
+
+    def load_scene
+      unless File.exist?(@scene_file)
+        raise "Scene file not found: #{@scene_file}"
+      end
+
+      scene = YAML.load_file(@scene_file)
+
+      # Convert string keys to symbols
+      scene.transform_keys(&:to_sym)
+    end
+
+    def start_actors
+      puts "\n[DIRECTOR: Calling actors to the stage...]\n"
+
+      @scene_info[:characters].each do |character_name|
+        character_file = File.join(@character_dir, "#{character_name.downcase}.yml")
+
+        unless File.exist?(character_file)
+          puts "Warning: Character file not found: #{character_file}"
+          next
+        end
+
+        puts "  - #{character_name} is taking their position..."
+
+        # Spawn actor process
+        pid = spawn(
+          "ruby", "actor.rb",
+          "-c", character_file,
+          "-s", @scene_file,
+          out: "logs/#{character_name.downcase}_#{Time.now.to_i}.log",
+          err: "logs/#{character_name.downcase}_#{Time.now.to_i}_err.log",
+        )
+
+        @actor_processes << { name: character_name, pid: pid }
+
+        # Give actors time to initialize
+        sleep 0.5
+      end
+
+      puts "\n[DIRECTOR: All actors ready!]\n"
+      sleep 1  # Give them time to subscribe to channels
+    end
+
+    def stop_actors
+      puts "\n[DIRECTOR: Dismissing actors...]\n"
+
+      @actor_processes.each do |actor|
+        begin
+          Process.kill("INT", actor[:pid])
+          Process.wait(actor[:pid])
+          puts "  - #{actor[:name]} has left the stage"
+        rescue Errno::ESRCH
+          # Process already ended
+        end
+      end
+
+      @actor_processes.clear
+    end
+
+    def send_control_message(command)
+      message = case command
+        when "start"
+          SceneControlMessage.start_scene(@scene_info[:scene_number])
+        when "stop"
+          SceneControlMessage.stop_scene(@scene_info[:scene_number])
+        when "end"
+          SceneControlMessage.end_scene(@scene_info[:scene_number])
+        else
+          return
+        end
+
+      message.publish
+      debug_me("Sent control message: #{command}")
+    end
+
+    def monitor_scene
+      puts "\n[SCENE BEGINS]\n\n"
+
+      line_count = 0
+      max_lines = ENV["MAX_LINES"]&.to_i || 50  # Default to 50 lines
+
+      # Subscribe to dialog messages
+      DialogMessage.subscribe("writers_room:dialog") do |message|
+        break unless @running
+        break if line_count >= max_lines
+
+        # Only show messages for this scene
+        next unless message.scene == @scene_info[:scene_number]
+
+        # Record in transcript
+        @transcript << {
+          type: :dialog,
+          character: message.from,
+          line: message.content,
+          timestamp: message.timestamp,
+          emotion: message.emotion,
+        }
+
+        # Display dialog
+        emotion_tag = message.emotion ? " [#{message.emotion}]" : ""
+        puts "#{message.from}#{emotion_tag}: #{message.content}"
+
+        line_count += 1
+
+        # Check if we should end the scene
+        if line_count >= max_lines
+          puts "\n[DIRECTOR: Maximum lines reached]"
+          cut!
+        end
+      end
+    end
+  end
+end

data/lib/writers_room/version.rb

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

data/lib/writers_room.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+require_relative "writers_room/version"
+
+module WritersRoom
+  class Error < StandardError; end
+end
+
+# Shortcut constant for convenience
+WR = WritersRoom

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: writers_room
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dewayne VanHoozer
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: under development
+email:
+- dvanhoozer@gmail.com
+executables:
+- wr
+extensions: []
+extra_rdoc_files: []
+files:
+- ".envrc"
+- CHANGELOG.md
+- COMMITS.md
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/wr
+- docs/configuration.md
+- docs/project_structure.md
+- docs/quick_reference.md
+- docs/quick_start.md
+- lib/writers_room.rb
+- lib/writers_room/actor.rb
+- lib/writers_room/cli.rb
+- lib/writers_room/cli/actor.rb
+- lib/writers_room/cli/config.rb
+- lib/writers_room/cli/direct.rb
+- lib/writers_room/cli/init.rb
+- lib/writers_room/cli/version.rb
+- lib/writers_room/config.rb
+- lib/writers_room/director.rb
+- lib/writers_room/version.rb
+homepage: https://github.com/madbomber/writers_room
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/madbomber/writers_room
+  source_code_uri: https://github.com/madbomber/writers_room
+  changelog_uri: https://github.com/madbomber/writers_room/blob/main/CHANGELOG.md
+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.7.2
+specification_version: 4
+summary: A Ruby gem for managing a writers' room
+test_files: []