prompt_objects 0.5.0 → 0.7.0

data/lib/prompt_objects/cli/explore_command.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PromptObjects
+  module CLI
+    # `explore` command: open the Thread Explorer visualizer in a browser.
+    class ExploreCommand
+      def run(args)
+        options = { session_id: nil }
+        positional = []
+        skip_next = false
+
+        args.each_with_index do |arg, i|
+          if skip_next
+            skip_next = false
+            next
+          end
+
+          case arg
+          when "--session"
+            options[:session_id] = args[i + 1]
+            skip_next = true
+          when "--help", "-h"
+            help
+            exit 0
+          else
+            positional << arg
+          end
+        end
+
+        explorer_html = File.expand_path("../../../tools/thread-explorer.html", __dir__)
+
+        # No args: just open the empty visualizer
+        unless positional[0]
+          Helpers.open_in_browser("file://#{explorer_html}")
+          puts "Opened Thread Explorer in browser"
+          exit 0
+        end
+
+        env_path = Helpers.resolve_environment(positional[0])
+        unless env_path
+          $stderr.puts "Error: environment '#{positional[0]}' not found"
+          exit 1
+        end
+
+        db_path = File.join(env_path, "sessions.db")
+        unless File.exist?(db_path)
+          $stderr.puts "No session data found (sessions.db not found)"
+          $stderr.puts "Opening empty Thread Explorer..."
+          Helpers.open_in_browser("file://#{explorer_html}")
+          exit 0
+        end
+
+        store = PromptObjects::Session::Store.new(db_path)
+
+        if options[:session_id]
+          # Export a specific thread
+          export_and_open(store, options[:session_id], explorer_html)
+        else
+          # List sessions and let user choose, or export the most recent root thread
+          # Query root sessions directly (list_sessions requires po_name)
+          rows = store.instance_variable_get(:@db).execute(<<~SQL)
+            SELECT * FROM sessions
+            WHERE thread_type IS NULL OR thread_type = 'root'
+            ORDER BY created_at ASC
+          SQL
+          root_sessions = rows.map { |r| { id: r["id"], po_name: r["po_name"], name: r["name"], thread_type: r["thread_type"], created_at: r["created_at"] } }
+
+          if root_sessions.empty?
+            $stderr.puts "No root sessions found"
+            Helpers.open_in_browser("file://#{explorer_html}")
+            exit 0
+          end
+
+          # Show available sessions
+          puts "Root threads:"
+          root_sessions.last(10).each_with_index do |s, i|
+            name = s[:name] || "(unnamed)"
+            po = s[:po_name] || "?"
+            time = s[:created_at]
+            time_str = time.is_a?(Time) ? time.strftime("%Y-%m-%d %H:%M") : time.to_s[0, 16]
+            puts "  #{i + 1}. [#{po}] #{name}  (#{time_str})  #{s[:id]}"
+          end
+
+          puts
+          puts "Opening most recent thread..."
+          export_and_open(store, root_sessions.last[:id], explorer_html)
+        end
+
+        store.close
+      end
+
+      def help
+        prog = Helpers.program_name
+        puts <<~HELP
+          Usage: #{prog} explore [env] [options]
+
+          Open the Thread Explorer to visualize conversation threads.
+
+          Arguments:
+            env                  Environment name or path (optional)
+
+          Options:
+            --session ID         Open a specific thread by session ID
+            --help, -h           Show this help message
+
+          Examples:
+            #{prog} explore                          # Open empty explorer
+            #{prog} explore my-env                   # Open most recent thread
+            #{prog} explore my-env --session abc123  # Open specific thread
+        HELP
+      end
+
+      private
+
+      def export_and_open(store, session_id, explorer_html)
+        data = store.export_thread_tree_json(session_id)
+        unless data
+          $stderr.puts "Error: session '#{session_id}' not found"
+          exit 1
+        end
+
+        json_str = JSON.generate(data)
+
+        # Read the explorer HTML and inject the data as auto-load
+        html_content = File.read(explorer_html)
+        inject_script = <<~JS
+          <script>
+          // Auto-load embedded data
+          window.addEventListener('DOMContentLoaded', function() {
+            var data = #{json_str};
+            if (typeof loadData === 'function') loadData(data);
+          });
+          </script>
+        JS
+
+        # Insert before </body>
+        html_content = html_content.sub("</body>", "#{inject_script}</body>")
+
+        # Write to temp file
+        require "tempfile"
+        tmp = Tempfile.new(["thread-explorer-", ".html"])
+        tmp.write(html_content)
+        tmp.close
+
+        Helpers.open_in_browser("file://#{tmp.path}")
+        puts "Opened Thread Explorer for session #{session_id}"
+
+        # Keep temp file around briefly so the browser can load it
+        sleep 2
+      end
+    end
+  end
+end

data/lib/prompt_objects/cli/helpers.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module CLI
+    # Shared helpers for CLI commands.
+    module Helpers
+      module_function
+
+      # The name the CLI was invoked as (e.g. "prompt_objects" or "poop").
+      # Used in usage/help text so each executable describes itself.
+      def program_name
+        name = File.basename($PROGRAM_NAME.to_s)
+        name.empty? ? "prompt_objects" : name
+      end
+
+      # Resolve an environment name or path to an environment directory.
+      # @param name_or_path [String]
+      # @return [String, nil] Path to the environment, or nil if not found
+      def resolve_environment(name_or_path)
+        # Check if it's already a path
+        if File.directory?(name_or_path)
+          manifest_path = File.join(name_or_path, "manifest.yml")
+          return name_or_path if File.exist?(manifest_path)
+        end
+
+        # Check in standard locations
+        locations = [
+          File.join(Dir.home, ".prompt_objects", "environments", name_or_path),
+          File.join(".", name_or_path)
+        ]
+
+        locations.each do |path|
+          manifest_path = File.join(path, "manifest.yml")
+          return path if File.exist?(manifest_path)
+        end
+
+        nil
+      end
+
+      # Load all prompt objects from an environment into a runtime.
+      def load_all_objects(runtime, env_path)
+        objects_dir = File.join(env_path, "objects")
+        return unless Dir.exist?(objects_dir)
+
+        Dir.glob(File.join(objects_dir, "*.md")).each do |path|
+          runtime.load_prompt_object(path)
+        rescue StandardError => e
+          $stderr.puts "Warning: Failed to load #{path}: #{e.message}"
+        end
+
+        runtime.registry.prompt_objects.each do |po|
+          runtime.load_dependencies(po)
+        end
+      end
+
+      # Open a URL in the platform browser.
+      def open_in_browser(url)
+        case RUBY_PLATFORM
+        when /darwin/
+          system("open", url)
+        when /linux/
+          system("xdg-open", url)
+        when /mswin|mingw|cygwin/
+          system("start", url)
+        else
+          $stderr.puts "Open this URL in your browser: #{url}"
+        end
+      end
+
+      # Print a list of bus events in the standard one-line format.
+      def print_events(events)
+        if events.empty?
+          puts "No events found."
+          return
+        end
+
+        events.each do |e|
+          ts = e[:timestamp] || e["timestamp"]
+          ts = ts.is_a?(Time) ? ts.strftime("%H:%M:%S") : ts&.split("T")&.last&.split(".")&.first
+          from = e[:from] || e["from"]
+          to = e[:to] || e["to"]
+          summary = e[:summary] || e["summary"]
+
+          line = "#{ts}  #{from} -> #{to}: #{summary}"
+          line = line[0, 120] + "..." if line.length > 123
+          puts line
+        end
+      end
+    end
+  end
+end

data/lib/prompt_objects/cli/message_command.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PromptObjects
+  module CLI
+    # `message` command: send a message to a PO and print the response.
+    # Routes through a running server when one exists, standalone otherwise.
+    class MessageCommand
+      def run(args)
+        options = {
+          json: false,
+          events: false,
+          new_thread: false,
+          session_id: nil
+        }
+
+        positional = []
+        skip_next = false
+
+        args.each_with_index do |arg, i|
+          if skip_next
+            skip_next = false
+            next
+          end
+
+          case arg
+          when "--json"
+            options[:json] = true
+          when "--events"
+            options[:events] = true
+          when "--new-thread"
+            options[:new_thread] = true
+          when "--session"
+            options[:session_id] = args[i + 1]
+            skip_next = true
+          when "--help", "-h"
+            help
+            exit 0
+          else
+            positional << arg
+          end
+        end
+
+        env_name = positional[0]
+        po_name = positional[1]
+        message_text = positional[2]
+
+        unless env_name && po_name && message_text
+          puts "Error: environment, po_name, and message are required"
+          puts "Run '#{Helpers.program_name} message --help' for usage"
+          exit 1
+        end
+
+        # Resolve environment
+        env_path = Helpers.resolve_environment(env_name)
+        unless env_path
+          $stderr.puts "Error: environment '#{env_name}' not found"
+          exit 1
+        end
+
+        # Check for running server
+        require "prompt_objects/server"
+        server_info = PromptObjects::Server.read_server_file(env_path)
+
+        if server_info
+          # Send via HTTP to running server
+          send_via_http(server_info, po_name, message_text, options)
+        else
+          # Standalone mode
+          send_standalone(env_path, po_name, message_text, options)
+        end
+      end
+
+      def help
+        prog = Helpers.program_name
+        puts <<~HELP
+          Usage: #{prog} message [options] <environment> <po_name> "message"
+
+          Send a message to a prompt object and print the response.
+
+          Arguments:
+            environment  Environment name or path
+            po_name      Name of the prompt object to message
+            message      The message to send (quoted string)
+
+          Options:
+            --json           Output response as JSON
+            --events         Also print the event log for this interaction
+            --new-thread     Start a new thread for this message
+            --session ID     Continue a specific thread ID (session alias)
+            --help, -h       Show this help
+
+          If a server is running for the environment, the message is sent via
+          HTTP to the running server (and streams to the web UI in real time).
+          Otherwise, a standalone runtime is started for the request.
+
+          Examples:
+            #{prog} message my-env solver "What patterns do you see?"
+            #{prog} message my-env solver "Solve task 1" --json
+            #{prog} message my-env solver "Try again" --new-thread
+        HELP
+      end
+
+      private
+
+      def send_via_http(server_info, po_name, message_text, options)
+        require "net/http"
+        require "uri"
+
+        uri = URI("http://#{server_info[:host]}:#{server_info[:port]}/api/prompt_objects/#{po_name}/message")
+
+        body = { message: message_text }
+        body[:new_thread] = true if options[:new_thread]
+        body[:session_id] = options[:session_id] if options[:session_id]
+        body[:client_request_id] = SecureRandom.uuid
+        body[:from_source] = "api:cli"
+
+        begin
+          response = Net::HTTP.post(uri, body.to_json, "Content-Type" => "application/json")
+          data = JSON.parse(response.body)
+
+          if data["error"]
+            $stderr.puts "Error: #{data['error']}"
+            exit 1
+          end
+
+          if options[:json]
+            puts JSON.pretty_generate(data)
+          else
+            puts data["response"]
+          end
+
+          if options[:events] && data["session_id"]
+            events_uri = URI("http://#{server_info[:host]}:#{server_info[:port]}/api/events/session/#{data['session_id']}")
+            events_response = Net::HTTP.get(events_uri)
+            events_data = JSON.parse(events_response)
+
+            if events_data["events"]&.any?
+              $stderr.puts
+              $stderr.puts "--- Events ---"
+              events_data["events"].each do |e|
+                $stderr.puts "#{e['timestamp']}  #{e['from']} -> #{e['to']}: #{e['summary']}"
+              end
+              $stderr.puts "--------------"
+            end
+          end
+        rescue Errno::ECONNREFUSED
+          $stderr.puts "Error: Server at #{server_info[:host]}:#{server_info[:port]} is not responding"
+          $stderr.puts "The .server file may be stale. Try running standalone."
+          exit 1
+        end
+      end
+
+      def send_standalone(env_path, po_name, message_text, options)
+        runtime = PromptObjects::Runtime.new(env_path: env_path)
+        Helpers.load_all_objects(runtime, env_path)
+
+        po = runtime.registry.get(po_name)
+        unless po.is_a?(PromptObjects::PromptObject)
+          $stderr.puts "Error: prompt object '#{po_name}' not found"
+          $stderr.puts "Available: #{runtime.loaded_objects.join(', ')}"
+          exit 1
+        end
+
+        workspace_id = runtime.active_session(initiated_by: "api:cli")[:id]
+        thread_id = options[:session_id]
+        if options[:new_thread]
+          thread_id = runtime.create_runtime_thread(
+            workspace_session_id: workspace_id,
+            po_name: po_name,
+            thread_type: "api",
+            name: "CLI thread"
+          ).id
+        end
+        run, response = runtime.execute_message_run(
+          target_po: po_name,
+          content: message_text,
+          from_source: "api:cli",
+          workspace_session_id: workspace_id,
+          thread_id: thread_id,
+          client_request_id: SecureRandom.uuid,
+          tui_mode: true
+        )
+
+        if options[:json]
+          puts JSON.pretty_generate(
+            response: response,
+            po_name: po_name,
+            workspace_session_id: run.workspace_session_id,
+            thread_id: run.thread_id,
+            session_id: run.thread_id,
+            run_id: run.id,
+            status: run.status
+          )
+        else
+          puts response
+        end
+
+        print_run_events(runtime, run.id) if options[:events]
+      end
+
+      def print_run_events(runtime, run_id)
+        events = Repositories::EventRepository.new(runtime.session_store).run_events(run_id: run_id)
+        return if events.empty?
+
+        $stderr.puts
+        $stderr.puts "--- Run Events ---"
+        events.each do |event|
+          $stderr.puts "#{event.timestamp.strftime('%H:%M:%S')}  #{event.kind}"
+        end
+        $stderr.puts "------------------"
+      end
+    end
+  end
+end