prompt_objects 0.1.0

data/lib/prompt_objects/server/api/routes.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack"
+
+module PromptObjects
+  module Server
+    module API
+      # REST API routes for the PromptObjects server.
+      # Provides endpoints for listing POs, sessions, and environment info.
+      class Routes
+        def initialize(runtime)
+          @runtime = runtime
+        end
+
+        def call(env)
+          request = Rack::Request.new(env)
+          path = request.path_info.sub("/api", "")
+
+          response = route(request, path)
+          json_response(response)
+        rescue => e
+          json_response({ error: e.message }, status: 500)
+        end
+
+        private
+
+        def route(request, path)
+          method = request.request_method
+
+          case [method, path]
+
+          # Environment
+          when ["GET", "/environment"]
+            get_environment
+
+          # Prompt Objects
+          when ["GET", "/prompt_objects"]
+            list_prompt_objects
+
+          when ["GET", %r{^/prompt_objects/([^/]+)$}]
+            get_prompt_object(path_param(path, 1))
+
+          when ["POST", "/prompt_objects"]
+            create_prompt_object(request.body.read)
+
+          # Sessions
+          when ["GET", %r{^/prompt_objects/([^/]+)/sessions$}]
+            list_sessions(path_param(path, 1))
+
+          when ["GET", %r{^/prompt_objects/([^/]+)/sessions/([^/]+)$}]
+            get_session(path_param(path, 1), path_param(path, 2))
+
+          when ["POST", %r{^/prompt_objects/([^/]+)/sessions$}]
+            create_session(path_param(path, 1), request.body.read)
+
+          # Primitives
+          when ["GET", "/primitives"]
+            list_primitives
+
+          # Message Bus
+          when ["GET", "/bus/recent"]
+            get_recent_bus_messages
+
+          else
+            { error: "Not found", path: path }
+          end
+        end
+
+        # === Environment ===
+
+        def get_environment
+          manifest_data = if @runtime.manifest
+            {
+              name: @runtime.manifest.name,
+              description: @runtime.manifest.description,
+              icon: @runtime.manifest.icon,
+              created_at: @runtime.manifest.created_at&.iso8601,
+              last_opened: @runtime.manifest.last_opened&.iso8601
+            }
+          end
+
+          {
+            name: @runtime.name,
+            path: @runtime.env_path,
+            prompt_object_count: @runtime.registry.prompt_objects.size,
+            primitive_count: @runtime.registry.primitives.size,
+            manifest: manifest_data
+          }
+        end
+
+        # === Prompt Objects ===
+
+        def list_prompt_objects
+          pos = @runtime.registry.prompt_objects.map do |po|
+            po_summary(po)
+          end
+
+          { prompt_objects: pos }
+        end
+
+        def get_prompt_object(name)
+          po = @runtime.registry.get(name)
+
+          unless po.is_a?(PromptObject)
+            return { error: "Not found", name: name }
+          end
+
+          po_full(po)
+        end
+
+        def create_prompt_object(body)
+          # TODO: Implement PO creation via API
+          { error: "Not implemented" }
+        end
+
+        # === Sessions ===
+
+        def list_sessions(po_name)
+          po = @runtime.registry.get(po_name)
+
+          unless po.is_a?(PromptObject)
+            return { error: "Not found", name: po_name }
+          end
+
+          sessions = po.list_sessions.map do |s|
+            {
+              id: s[:id],
+              name: s[:name],
+              message_count: s[:message_count] || 0,
+              created_at: s[:created_at]&.iso8601,
+              updated_at: s[:updated_at]&.iso8601
+            }
+          end
+
+          { sessions: sessions }
+        end
+
+        def get_session(po_name, session_id)
+          po = @runtime.registry.get(po_name)
+
+          unless po.is_a?(PromptObject)
+            return { error: "Prompt object not found", name: po_name }
+          end
+
+          return { error: "No session store" } unless @runtime.session_store
+
+          session = @runtime.session_store.get_session(session_id)
+
+          unless session && session[:po_name] == po_name
+            return { error: "Session not found", id: session_id }
+          end
+
+          messages = @runtime.session_store.get_messages(session_id)
+
+          {
+            id: session[:id],
+            name: session[:name],
+            po_name: session[:po_name],
+            messages: messages.map { |m| format_message(m) },
+            created_at: session[:created_at]&.iso8601,
+            updated_at: session[:updated_at]&.iso8601
+          }
+        end
+
+        def create_session(po_name, body)
+          po = @runtime.registry.get(po_name)
+
+          unless po.is_a?(PromptObject)
+            return { error: "Not found", name: po_name }
+          end
+
+          params = body.empty? ? {} : JSON.parse(body)
+          session_name = params["name"]
+
+          session_id = po.new_session(name: session_name)
+
+          {
+            success: true,
+            session_id: session_id,
+            name: session_name
+          }
+        end
+
+        # === Primitives ===
+
+        def list_primitives
+          primitives = @runtime.registry.primitives.map do |p|
+            {
+              name: p.name,
+              description: p.description
+            }
+          end
+
+          { primitives: primitives }
+        end
+
+        # === Message Bus ===
+
+        def get_recent_bus_messages
+          entries = @runtime.bus.recent(50)
+
+          messages = entries.map do |e|
+            {
+              from: e[:from],
+              to: e[:to],
+              message: e[:message],
+              timestamp: e[:timestamp].iso8601
+            }
+          end
+
+          { messages: messages }
+        end
+
+        # === Helpers ===
+
+        def po_summary(po)
+          {
+            name: po.name,
+            description: po.description,
+            capabilities: po.config["capabilities"] || [],
+            session_count: po.list_sessions.size
+          }
+        end
+
+        def po_full(po)
+          {
+            name: po.name,
+            description: po.description,
+            capabilities: po.config["capabilities"] || [],
+            body: po.body,
+            config: po.config,
+            sessions: po.list_sessions.map do |s|
+              {
+                id: s[:id],
+                name: s[:name],
+                message_count: s[:message_count] || 0
+              }
+            end,
+            current_session: po.session_id,
+            history: po.history.map { |m| format_history_message(m) }
+          }
+        end
+
+        def format_message(msg)
+          {
+            role: msg[:role].to_s,
+            content: msg[:content],
+            from_po: msg[:from_po],
+            tool_calls: msg[:tool_calls],
+            tool_results: msg[:tool_results],
+            created_at: msg[:created_at]&.iso8601
+          }.compact
+        end
+
+        def format_history_message(msg)
+          case msg[:role]
+          when :user
+            { role: "user", content: msg[:content], from: msg[:from] }
+          when :assistant
+            h = { role: "assistant", content: msg[:content] }
+            if msg[:tool_calls]
+              h[:tool_calls] = msg[:tool_calls].map do |tc|
+                { id: tc.id, name: tc.name, arguments: tc.arguments }
+              end
+            end
+            h
+          when :tool
+            { role: "tool", results: msg[:results] }
+          else
+            { role: msg[:role].to_s, content: msg[:content] }
+          end
+        end
+
+        def path_param(path, index)
+          # Extract path parameter from regex match
+          # /prompt_objects/foo -> foo (index 1)
+          # /prompt_objects/foo/sessions/bar -> foo (1), bar (2)
+          parts = path.split("/").reject(&:empty?)
+          parts[index]
+        end
+
+        def json_response(data, status: 200)
+          body = JSON.generate(data)
+          [
+            status,
+            {
+              "content-type" => "application/json",
+              "access-control-allow-origin" => "*"
+            },
+            [body]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/prompt_objects/server/app.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "async/websocket/adapters/rack"
+require "json"
+require "rack"
+
+module PromptObjects
+  module Server
+    # Main Rack application for the PromptObjects web server.
+    # Routes requests to WebSocket handler, API, or static assets.
+    class App
+      STATIC_EXTENSIONS = %w[.html .js .css .png .svg .ico .woff .woff2 .map .json].freeze
+
+      attr_reader :connections
+
+      def initialize(runtime)
+        @runtime = runtime
+        @api = API::Routes.new(runtime)
+        @public_path = File.expand_path("public", __dir__)
+        @connections = []
+        @connections_mutex = Mutex.new
+      end
+
+      def call(env)
+        request_path = env["PATH_INFO"]
+
+        if websocket_request?(env)
+          handle_websocket(env)
+        elsif request_path.start_with?("/api/")
+          @api.call(env)
+        elsif static_asset?(request_path)
+          serve_static(request_path)
+        else
+          serve_index
+        end
+      end
+
+      # Broadcast a message to all connected WebSocket clients.
+      # @param message [Hash] Message to broadcast
+      def broadcast(message)
+        @connections_mutex.synchronize do
+          @connections.each do |handler|
+            handler.send_message(message)
+          rescue StandardError => e
+            puts "Broadcast error: #{e.message}" if ENV["DEBUG"]
+          end
+        end
+      end
+
+      # Register a connection handler.
+      def register_connection(handler)
+        @connections_mutex.synchronize do
+          @connections << handler
+        end
+      end
+
+      # Unregister a connection handler.
+      def unregister_connection(handler)
+        @connections_mutex.synchronize do
+          @connections.delete(handler)
+        end
+      end
+
+      private
+
+      def websocket_request?(env)
+        env["HTTP_UPGRADE"]&.downcase == "websocket"
+      end
+
+      def handle_websocket(env)
+        Async::WebSocket::Adapters::Rack.open(env, protocols: ["json"]) do |connection|
+          handler = WebSocketHandler.new(
+            runtime: @runtime,
+            connection: connection,
+            app: self
+          )
+
+          register_connection(handler)
+          begin
+            handler.run
+          ensure
+            unregister_connection(handler)
+          end
+        end
+      end
+
+      def static_asset?(path)
+        STATIC_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+      end
+
+      def serve_static(path)
+        # Security: prevent directory traversal
+        safe_path = File.expand_path(File.join(@public_path, path))
+        unless safe_path.start_with?(@public_path)
+          return [403, { "content-type" => "text/plain" }, ["Forbidden"]]
+        end
+
+        if File.exist?(safe_path) && File.file?(safe_path)
+          content_type = content_type_for(path)
+          body = File.read(safe_path)
+          [200, { "content-type" => content_type }, [body]]
+        else
+          [404, { "content-type" => "text/plain" }, ["Not found"]]
+        end
+      end
+
+      def serve_index
+        index_path = File.join(@public_path, "index.html")
+
+        if File.exist?(index_path)
+          body = File.read(index_path)
+          [200, { "content-type" => "text/html" }, [body]]
+        else
+          # If no frontend is built yet, serve a placeholder
+          [200, { "content-type" => "text/html" }, [placeholder_html]]
+        end
+      end
+
+      def content_type_for(path)
+        case File.extname(path)
+        when ".html" then "text/html"
+        when ".js" then "application/javascript"
+        when ".css" then "text/css"
+        when ".json" then "application/json"
+        when ".svg" then "image/svg+xml"
+        when ".png" then "image/png"
+        when ".ico" then "image/x-icon"
+        when ".woff" then "font/woff"
+        when ".woff2" then "font/woff2"
+        when ".map" then "application/json"
+        else "application/octet-stream"
+        end
+      end
+
+      def placeholder_html
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>PromptObjects</title>
+            <style>
+              body {
+                font-family: system-ui, -apple-system, sans-serif;
+                max-width: 600px;
+                margin: 100px auto;
+                padding: 20px;
+                background: #1a1a2e;
+                color: #eee;
+              }
+              h1 { color: #7c3aed; }
+              code {
+                background: #2d2d44;
+                padding: 2px 6px;
+                border-radius: 4px;
+              }
+              .status { color: #22c55e; }
+            </style>
+          </head>
+          <body>
+            <h1>PromptObjects</h1>
+            <p class="status">Server is running</p>
+            <p>Environment: <code>#{@runtime.name}</code></p>
+            <p>Prompt Objects: <code>#{@runtime.registry.prompt_objects.size}</code></p>
+            <p>WebSocket endpoint: <code>ws://localhost:PORT/</code></p>
+            <hr>
+            <p>The React frontend has not been built yet.</p>
+            <p>For now, you can connect via WebSocket to interact with POs.</p>
+          </body>
+          </html>
+        HTML
+      end
+    end
+  end
+end

data/lib/prompt_objects/server/file_watcher.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "listen"
+
+module PromptObjects
+  module Server
+    # Watches the environment directory for file changes and notifies subscribers.
+    # This enables live updates when POs are created/modified/deleted.
+    class FileWatcher
+      def initialize(runtime:, env_path:)
+        @runtime = runtime
+        @env_path = env_path
+        @subscribers = []
+        @listener = nil
+      end
+
+      def start
+        objects_dir = File.join(@env_path, "objects")
+
+        unless Dir.exist?(objects_dir)
+          puts "FileWatcher: objects directory not found at #{objects_dir}"
+          return
+        end
+
+        @listener = Listen.to(objects_dir, only: /\.md$/) do |modified, added, removed|
+          handle_changes(modified: modified, added: added, removed: removed)
+        end
+
+        @listener.start
+        puts "FileWatcher: watching #{objects_dir} for changes"
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      def subscribe(&block)
+        @subscribers << block
+      end
+
+      def unsubscribe(block)
+        @subscribers.delete(block)
+      end
+
+      private
+
+      def handle_changes(modified:, added:, removed:)
+        # Handle added files
+        added.each { |path| handle_po_added(path) }
+
+        # Handle modified files
+        modified.each { |path| handle_po_modified(path) }
+
+        # Handle removed files
+        removed.each { |path| handle_po_removed(path) }
+      end
+
+      def handle_po_added(path)
+        name = File.basename(path, ".md")
+
+        # Skip if already loaded (e.g., by create_capability)
+        # The on_po_registered callback will have already broadcast
+        if @runtime.registry.exists?(name)
+          puts "FileWatcher: PO already loaded - #{name} (skipping)"
+          return
+        end
+
+        puts "FileWatcher: PO added - #{name}"
+
+        begin
+          po = @runtime.load_prompt_object(path)
+          @runtime.load_dependencies(po)
+          notify(:po_added, po)
+        rescue StandardError => e
+          puts "FileWatcher: Failed to load #{name}: #{e.message}"
+        end
+      end
+
+      def handle_po_modified(path)
+        name = File.basename(path, ".md")
+        puts "FileWatcher: PO modified - #{name}"
+
+        begin
+          # Remove the old version from registry
+          @runtime.registry.unregister(name)
+
+          # Load the new version
+          po = @runtime.load_prompt_object(path)
+          @runtime.load_dependencies(po)
+          notify(:po_modified, po)
+        rescue StandardError => e
+          puts "FileWatcher: Failed to reload #{name}: #{e.message}"
+        end
+      end
+
+      def handle_po_removed(path)
+        name = File.basename(path, ".md")
+        puts "FileWatcher: PO removed - #{name}"
+
+        removed = @runtime.registry.unregister(name)
+        notify(:po_removed, { name: name }) if removed
+      end
+
+      def notify(event, data)
+        @subscribers.each do |subscriber|
+          subscriber.call(event, data)
+        rescue StandardError => e
+          puts "FileWatcher subscriber error: #{e.message}"
+        end
+      end
+    end
+  end
+end