prompt_objects 0.6.0 → 0.7.0

data/lib/prompt_objects/connectors/mcp.rb

@@ -89,9 +89,12 @@ module PromptObjects
         po = @runtime.registry.get(po_name)
         return [{ uri: "po://#{po_name}/conversation", mimeType: "text/plain", text: "PO not found" }] unless po
 
-        history = po.history.map do |msg|
-          { role: msg[:role].to_s, content: msg[:content] }
-        end
+        workspace_id = @runtime.active_session(initiated_by: "service:mcp")[:id]
+        thread = Repositories::ThreadRepository.new(@runtime.session_store)
+          .list(workspace_session_id: workspace_id, po_name: po_name).last
+        history = thread ? Repositories::MessageRepository.new(@runtime.session_store)
+          .list(thread_id: thread.id, limit: 10_000)
+          .map { |msg| { role: msg[:role].to_s, content: msg[:content] } } : []
 
         [{
           uri: "po://#{po_name}/conversation",
@@ -143,7 +146,10 @@ module PromptObjects
       def read_sessions(po_name)
         return [{ uri: "sessions://#{po_name}", mimeType: "text/plain", text: "Sessions not available" }] unless @runtime.session_store
 
-        sessions = @runtime.session_store.list_sessions(po_name: po_name)
+        workspace_id = @runtime.active_session(initiated_by: "service:mcp")[:id]
+        sessions = Repositories::ThreadRepository.new(@runtime.session_store)
+          .list(workspace_session_id: workspace_id, po_name: po_name)
+          .map(&:to_h)
         [{
           uri: "sessions://#{po_name}",
           mimeType: "application/json",
@@ -154,7 +160,10 @@ module PromptObjects
       def read_all_sessions
         return [{ uri: "sessions://all", mimeType: "text/plain", text: "Sessions not available" }] unless @runtime.session_store
 
-        sessions = @runtime.session_store.list_all_sessions
+        workspace_id = @runtime.active_session(initiated_by: "service:mcp")[:id]
+        sessions = Repositories::ThreadRepository.new(@runtime.session_store)
+          .list(workspace_session_id: workspace_id)
+          .map(&:to_h)
         [{
           uri: "sessions://all",
           mimeType: "application/json",
@@ -211,17 +220,27 @@ module PromptObjects
               },
               session_id: {
                 type: "string",
-                description: "Optional session ID to continue. If not provided, uses or creates a default session."
+                description: "Compatibility alias for thread_id"
+              },
+              thread_id: {
+                type: "string",
+                description: "Optional runtime thread ID to continue"
+              },
+              workspace_session_id: {
+                type: "string",
+                description: "Optional workspace session ID"
+              },
+              client_request_id: {
+                type: "string",
+                description: "Optional idempotency key"
               }
             },
             required: %w[po_name message]
           )
 
-          def self.call(po_name:, message:, session_id: nil, server_context:)
+          def self.call(po_name:, message:, session_id: nil, thread_id: nil,
+                        workspace_session_id: nil, client_request_id: nil, server_context:)
             env = server_context[:env]
-            context = server_context[:context]
-            connector = server_context[:connector]
-
             po = env.registry.get(po_name)
             unless po.is_a?(PromptObjects::PromptObject)
               return ::MCP::Tool::Response.new([{
@@ -230,69 +249,30 @@ module PromptObjects
               }])
             end
 
-            # Handle session
-            current_session_id = setup_session(po, session_id, env, connector)
-
-            # Log to message bus
-            env.bus.publish(from: "mcp_client", to: po_name, message: message)
-
-            # Set context for this interaction
-            context.current_capability = po_name
-            po.state = :working
-
-            begin
-              response = po.receive(message, context: context)
-              po.state = :idle
-
-              # Update session source
-              connector&.send(:update_session_source, current_session_id) if current_session_id
-
-              # Log response
-              env.bus.publish(from: po_name, to: "mcp_client", message: response)
-
-              ::MCP::Tool::Response.new([{
-                type: "text",
-                text: JSON.generate({
-                  po_name: po_name,
-                  response: response,
-                  session_id: current_session_id,
-                  history_length: po.history.length
-                })
-              }])
-            rescue StandardError => e
-              po.state = :idle
-              ::MCP::Tool::Response.new([{
-                type: "text",
-                text: JSON.generate({ error: e.message, backtrace: e.backtrace.first(5) })
-              }])
-            end
-          end
-
-          def self.setup_session(po, session_id, env, connector)
-            return nil unless env.session_store
-
-            if session_id
-              # Switch to specified session
-              session = env.session_store.get_session(session_id)
-              if session && session[:po_name] == po.name
-                po.switch_session(session_id)
-                return session_id
-              end
-            end
-
-            # Use existing session or create new one
-            existing_id = po.instance_variable_get(:@session_id)
-            return existing_id if existing_id
-
-            # Create new MCP session
-            new_id = env.session_store.create_session(
-              po_name: po.name,
-              name: "MCP Session #{Time.now.strftime('%H:%M')}",
-              source: connector&.source_name || "mcp"
+            run, response = env.execute_message_run(
+              target_po: po_name,
+              content: message,
+              from_source: "service:mcp",
+              workspace_session_id: workspace_session_id,
+              thread_id: thread_id || session_id,
+              client_request_id: client_request_id,
+              tui_mode: true
             )
-            po.instance_variable_set(:@session_id, new_id)
-            po.send(:reload_history_from_session) if po.respond_to?(:reload_history_from_session, true)
-            new_id
+            history_length = Repositories::MessageRepository.new(env.session_store)
+              .list(thread_id: run.thread_id, limit: 10_000).length
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: JSON.generate({
+                po_name: po_name,
+                response: response,
+                workspace_session_id: run.workspace_session_id,
+                thread_id: run.thread_id,
+                session_id: run.thread_id,
+                run_id: run.id,
+                status: run.status,
+                history_length: history_length
+              })
+            }])
           end
         end
 
@@ -327,18 +307,20 @@ module PromptObjects
               }])
             end
 
-            history = if session_id && env.session_store
-                        messages = env.session_store.get_messages(session_id)
-                        messages.map { |m| { role: m[:role], content: m[:content] } }
-                      else
-                        po.history.map { |msg| { role: msg[:role].to_s, content: msg[:content] } }
-                      end
+            workspace_id = env.active_session(initiated_by: "service:mcp")[:id]
+            threads = Repositories::ThreadRepository.new(env.session_store)
+              .list(workspace_session_id: workspace_id, po_name: po_name)
+            thread = session_id ? threads.find { |candidate| candidate.id == session_id } : threads.last
+            history = thread ? Repositories::MessageRepository.new(env.session_store)
+              .list(thread_id: thread.id, limit: 10_000)
+              .map { |message| { role: message[:role].to_s, content: message[:content] } } : []
 
             ::MCP::Tool::Response.new([{
               type: "text",
               text: JSON.generate({
                 po_name: po_name,
-                session_id: session_id || po.instance_variable_get(:@session_id),
+                session_id: thread&.id,
+                thread_id: thread&.id,
                 history: history
               })
             }])
@@ -374,35 +356,37 @@ module PromptObjects
               }])
             end
 
-            sessions = if po_name
-                         env.session_store.list_sessions(po_name: po_name)
-                       else
-                         env.session_store.list_all_sessions(source: source)
-                       end
-
-            sessions_data = sessions.map do |s|
+            workspace_id = env.active_session(initiated_by: "service:mcp")[:id]
+            threads = Repositories::ThreadRepository.new(env.session_store)
+              .list(workspace_session_id: workspace_id, po_name: po_name)
+            threads = threads.select { |thread| thread.thread_type == source } if source
+            messages = Repositories::MessageRepository.new(env.session_store)
+            sessions_data = threads.map do |thread|
               {
-                id: s[:id],
-                po_name: s[:po_name],
-                name: s[:name],
-                source: s[:source],
-                message_count: env.session_store.message_count(s[:id]),
-                created_at: s[:created_at]&.iso8601,
-                updated_at: s[:updated_at]&.iso8601
+                id: thread.id,
+                thread_id: thread.id,
+                workspace_session_id: thread.workspace_session_id,
+                po_name: thread.po_name,
+                name: thread.name,
+                source: thread.thread_type,
+                thread_type: thread.thread_type,
+                message_count: messages.list(thread_id: thread.id, limit: 10_000).length,
+                created_at: thread.created_at&.iso8601,
+                updated_at: thread.updated_at&.iso8601
               }
             end
 
             ::MCP::Tool::Response.new([{
               type: "text",
-              text: JSON.generate({ sessions: sessions_data })
+              text: JSON.generate({ sessions: sessions_data, threads: sessions_data })
             }])
           end
         end
 
-        # Get pending human requests
+        # Get pending capability-approval requests.
         class GetPendingRequests < ::MCP::Tool
           tool_name "get_pending_requests"
-          description "Get all pending human requests across all prompt objects"
+          description "Get pending capability-approval requests"
 
           input_schema(
             type: "object",
@@ -428,10 +412,10 @@ module PromptObjects
           end
         end
 
-        # Respond to a human request
+        # Respond to a capability-approval request.
         class RespondToRequest < ::MCP::Tool
           tool_name "respond_to_request"
-          description "Respond to a pending human request"
+          description "Respond to a pending capability-approval request"
 
           input_schema(
             type: "object",

data/lib/prompt_objects/domain/records.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PromptObjects
+  module Domain
+    WorkspaceSession = Data.define(:id, :name, :status, :created_at, :updated_at, :metadata)
+
+    Thread = Data.define(
+      :id, :workspace_session_id, :po_name, :thread_type, :name,
+      :parent_thread_id, :parent_run_id, :retention_policy, :archived,
+      :created_at, :updated_at, :last_run_status, :last_activity_at
+    )
+
+    Run = Data.define(
+      :id, :client_request_id, :workspace_session_id, :thread_id, :po_name,
+      :turn_ordinal, :input_content, :input_message_id, :history_cutoff_message_id,
+      :definition_version, :provider, :model, :capability_policy_version,
+      :source_type, :source_name, :parent_run_id, :root_run_id, :status,
+      :priority, :enqueued_at, :started_at, :finished_at, :cancellation_reason,
+      :final_response, :usage, :error_class, :error_message, :metadata
+    )
+
+    RunEvent = Data.define(
+      :id, :run_id, :sequence, :workspace_cursor, :workspace_session_id,
+      :thread_id, :kind, :timestamp, :data
+    )
+
+    ToolExecution = Data.define(
+      :id, :provider_tool_call_id, :run_id, :batch_id, :batch_position,
+      :capability_name, :capability_policy_version, :status, :resource_keys,
+      :arguments, :result, :error_class, :error_message, :cancellation_reason,
+      :started_at, :finished_at
+    )
+
+    Artifact = Data.define(
+      :id, :workspace_session_id, :owner_po, :owner_thread_id,
+      :producing_run_id, :title, :html, :revision, :mode,
+      :created_at, :updated_at, :metadata
+    )
+
+    PromptObjectDefinition = Data.define(
+      :po_name, :version, :prompt, :config, :provider, :model,
+      :capability_policy_version
+    )
+  end
+end

data/lib/prompt_objects/environment/exporter.rb

@@ -2,7 +2,8 @@
 
 module PromptObjects
   module Env
-    # Exports an environment as a git bundle (.poenv file).
+    # Exports an environment as a git bundle (.dump file —
+    # Declarative Unified Memory Package).
     # The bundle contains all commits, objects, primitives, and manifest.
     # Sessions are NOT included (private data).
     class Exporter
@@ -13,7 +14,7 @@ module PromptObjects
       end
 
       # Export the environment to a git bundle.
-      # @param output_path [String] Path for the output .poenv file
+      # @param output_path [String] Path for the output .dump file
       # @param commit_message [String, nil] Message for any uncommitted changes
       # @return [Hash] Export result with :success, :path, :stats
       def export(output_path, commit_message: nil)
@@ -60,8 +61,8 @@ module PromptObjects
       end
 
       def normalize_output_path(path)
-        # Add .poenv extension if not present
-        path = "#{path}.poenv" unless path.end_with?(".poenv")
+        # Add .dump extension if not present (.poenv accepted for legacy paths)
+        path = "#{path}.dump" unless path.end_with?(".dump", ".poenv")
 
         # Expand to absolute path
         File.expand_path(path)

data/lib/prompt_objects/environment/git.rb

@@ -5,6 +5,9 @@ module PromptObjects
     # Git operations for environments.
     # Each environment is a git repository for built-in versioning.
     module Git
+      DEFAULT_USER_NAME = "Prompt Objects"
+      DEFAULT_USER_EMAIL = "prompt-objects@localhost"
+
       # Check if a directory is a git repository.
       # @param path [String]
       # @return [Boolean]
@@ -15,7 +18,9 @@ module PromptObjects
       # Initialize a git repository.
       # @param path [String]
       def self.init(path)
-        Dir.chdir(path) { system("git init --quiet") }
+        initialized = Dir.chdir(path) { system("git", "init", "--quiet") }
+        ensure_identity(path) if initialized
+        initialized
       end
 
       # Stage all changes.
@@ -29,6 +34,7 @@ module PromptObjects
       # @param message [String]
       # @return [Boolean] Success
       def self.commit(path, message)
+        ensure_identity(path)
         Dir.chdir(path) do
           system("git add -A")
           system("git", "commit", "--quiet", "-m", message)
@@ -113,6 +119,20 @@ module PromptObjects
         commit(path, message)
         true
       end
+
+      # New users may not have a global Git identity yet. Environment history
+      # should still work without modifying their global configuration, so use
+      # a repository-local automation identity only when no identity resolves.
+      def self.ensure_identity(path)
+        Dir.chdir(path) do
+          unless system("git", "config", "user.name", out: File::NULL, err: File::NULL)
+            system("git", "config", "user.name", DEFAULT_USER_NAME)
+          end
+          unless system("git", "config", "user.email", out: File::NULL, err: File::NULL)
+            system("git", "config", "user.email", DEFAULT_USER_EMAIL)
+          end
+        end
+      end
     end
   end
 end

data/lib/prompt_objects/environment/importer.rb

@@ -5,7 +5,8 @@ require "tmpdir"
 
 module PromptObjects
   module Env
-    # Imports an environment from a git bundle (.poenv file).
+    # Imports an environment from a git bundle (.dump file —
+    # Declarative Unified Memory Package; legacy .poenv bundles work too).
     # Handles security concerns around custom primitives.
     class Importer
       # Result of inspecting a bundle before import
@@ -20,7 +21,7 @@ module PromptObjects
         keyword_init: true
       )
 
-      # @param bundle_path [String] Path to the .poenv bundle file
+      # @param bundle_path [String] Path to the .dump (or legacy .poenv) bundle file
       def initialize(bundle_path)
         @bundle_path = File.expand_path(bundle_path)
       end
@@ -38,7 +39,7 @@ module PromptObjects
         end
 
         # Clone to temp dir to inspect contents
-        Dir.mktmpdir("poenv_inspect_") do |temp_dir|
+        Dir.mktmpdir("dump_inspect_") do |temp_dir|
           unless Git.clone_bundle(@bundle_path, temp_dir)
             return InspectResult.new(valid: false, error: "Failed to extract bundle")
           end
@@ -127,7 +128,7 @@ module PromptObjects
 
         InspectResult.new(
           valid: true,
-          name: manifest_name || File.basename(@bundle_path, ".poenv"),
+          name: manifest_name || File.basename(@bundle_path, ".*"),
           description: manifest_desc,
           objects: objects,
           primitives: primitives,

data/lib/prompt_objects/environment/manager.rb

@@ -127,6 +127,7 @@ module PromptObjects
         FileUtils.mkdir_p(env_path)
         FileUtils.mkdir_p(File.join(env_path, "objects"))
         FileUtils.mkdir_p(File.join(env_path, "primitives"))
+        FileUtils.mkdir_p(File.join(env_path, "services"))
 
         # Copy template if specified
         template_manifest = copy_template(env_path, template) if template
@@ -136,7 +137,10 @@ module PromptObjects
           name: name,
           description: description || template_manifest&.dig("description"),
           icon: template_manifest&.dig("icon") || "📦",
-          color: template_manifest&.dig("color") || "#4A90D9"
+          color: template_manifest&.dig("color") || "#4A90D9",
+          default_po: template_manifest&.dig("default_po"),
+          dependencies: template_manifest&.dig("dependencies"),
+          llm: template_manifest&.dig("llm")
         )
         manifest.save_to_dir(env_path)
 
@@ -252,6 +256,22 @@ module PromptObjects
         FileUtils.rm_rf(path)
       end
 
+      # Permanently delete an ACTIVE environment (its directory and all data).
+      # Clears the default if this was it. For a recoverable flow, archive first.
+      # @param name [String]
+      def destroy(name)
+        raise Error, "Environment '#{name}' not found" unless environment_exists?(name)
+        raise Error, "Cannot delete the development environment" if name == DEV_ENV_NAME
+
+        FileUtils.rm_rf(environment_path(name))
+
+        if default_environment == name
+          config = global_config
+          config.delete("default_environment")
+          save_global_config(config)
+        end
+      end
+
       # Clone an environment.
       # @param source_name [String]
       # @param new_name [String]
@@ -348,6 +368,27 @@ module PromptObjects
           FileUtils.cp_r(Dir.glob("#{template_primitives}/*"), File.join(env_path, "primitives"))
         end
 
+        # Copy services if present
+        template_services = File.join(template_path, "services")
+        if Dir.exist?(template_services)
+          FileUtils.mkdir_p(File.join(env_path, "services"))
+          FileUtils.cp_r(Dir.glob("#{template_services}/*"), File.join(env_path, "services"))
+        end
+
+        # Copy vendor (bundled gem dependencies) if present
+        template_vendor = File.join(template_path, "vendor")
+        if Dir.exist?(template_vendor)
+          FileUtils.mkdir_p(File.join(env_path, "vendor"))
+          FileUtils.cp_r(Dir.glob("#{template_vendor}/*"), File.join(env_path, "vendor"))
+        end
+
+        # Copy extras if present
+        template_extras = File.join(template_path, "extras")
+        if Dir.exist?(template_extras)
+          FileUtils.mkdir_p(File.join(env_path, "extras"))
+          FileUtils.cp_r(Dir.glob("#{template_extras}/*"), File.join(env_path, "extras"))
+        end
+
         template_manifest
       end
 
@@ -380,11 +421,8 @@ module PromptObjects
       # Initialize git repository.
       # @param env_path [String]
       def init_git(env_path)
-        Dir.chdir(env_path) do
-          system("git init --quiet")
-          system("git add .")
-          system("git commit --quiet -m 'Initial environment setup'")
-        end
+        Git.init(env_path)
+        Git.commit(env_path, "Initial environment setup")
       end
 
       # Ensure global config file exists.

data/lib/prompt_objects/environment/manifest.rb

@@ -14,7 +14,8 @@ module PromptObjects
 
       attr_accessor :name, :description, :created_at, :updated_at, :last_opened,
                     :icon, :color, :tags, :default_po, :stats, :version,
-                    :archived_at, :imported_from, :imported_at
+                    :archived_at, :imported_from, :imported_at, :dependencies,
+                    :runtime_model, :llm
 
       def initialize(
         name:,
@@ -30,7 +31,10 @@ module PromptObjects
         version: nil,
         archived_at: nil,
         imported_from: nil,
-        imported_at: nil
+        imported_at: nil,
+        dependencies: nil,
+        runtime_model: nil,
+        llm: nil
       )
         @name = name
         @description = description
@@ -46,6 +50,9 @@ module PromptObjects
         @archived_at = archived_at
         @imported_from = imported_from
         @imported_at = imported_at
+        @dependencies = dependencies || {}
+        @runtime_model = runtime_model || "runs"
+        @llm = llm || {}
       end
 
       # Load manifest from a file path.
@@ -83,7 +90,10 @@ module PromptObjects
           version: data["version"],
           archived_at: parse_time(data["archived_at"]),
           imported_from: data["imported_from"],
-          imported_at: parse_time(data["imported_at"])
+          imported_at: parse_time(data["imported_at"]),
+          dependencies: data["dependencies"],
+          runtime_model: data["runtime_model"],
+          llm: data["llm"]
         )
       end
 
@@ -116,7 +126,10 @@ module PromptObjects
           "color" => @color,
           "tags" => @tags.any? ? @tags : nil,
           "default_po" => @default_po,
-          "stats" => @stats
+          "stats" => @stats,
+          "dependencies" => @dependencies&.any? ? @dependencies : nil,
+          "runtime_model" => @runtime_model,
+          "llm" => @llm&.any? ? @llm : nil
         }.compact
       end
 
@@ -189,6 +202,7 @@ module PromptObjects
         lines << "  Created: #{@created_at&.strftime('%Y-%m-%d %H:%M')}"
         lines << "  Last opened: #{@last_opened&.strftime('%Y-%m-%d %H:%M')}" if @last_opened
         lines << "  Updated: #{@updated_at&.strftime('%Y-%m-%d %H:%M')}" if @updated_at
+        lines << "  LLM: #{@llm['provider']} / #{@llm['model']}" if @llm&.any?
 
         if imported?
           lines << ""
@@ -207,6 +221,14 @@ module PromptObjects
         lines << "    Sessions: #{@stats['total_sessions'] || 0}"
         lines << "    Messages: #{@stats['total_messages'] || 0}"
 
+        if @dependencies&.dig("gems")&.any?
+          lines << ""
+          lines << "  Dependencies:"
+          @dependencies["gems"].each do |gem_info|
+            lines << "    #{gem_info['name']} (#{gem_info['version']}) — #{gem_info['purpose']}"
+          end
+        end
+
         lines << ""
         lines << "  Tags: #{@tags.join(', ')}" if @tags&.any?
         lines << "  Format version: #{@version}"