prompt_objects 0.5.0 → 0.7.0

data/lib/prompt_objects/cli.rb

@@ -1,432 +1,74 @@
 # frozen_string_literal: true
 
+require_relative "cli/helpers"
+require_relative "cli/env_command"
+require_relative "cli/repl_command"
+require_relative "cli/serve_command"
+require_relative "cli/message_command"
+require_relative "cli/events_command"
+require_relative "cli/diagnostics_command"
+require_relative "cli/explore_command"
+
 module PromptObjects
-  # Command-line interface for environment management.
+  # Command-line interface. `CLI.run` is the single entry point used by the
+  # `prompt_objects` and `poop` executables; each command lives in its own
+  # class under lib/prompt_objects/cli/.
   module CLI
-    # Handle env subcommands: list, create, info, archive, restore, clone, etc.
-    class EnvCommand
-      def initialize(manager: nil)
-        @manager = manager || Env::Manager.new
-      end
-
-      # Run the env subcommand.
-      # @param args [Array<String>] Arguments after 'env'
-      def run(args)
-        subcommand = args.shift || "list"
-
-        case subcommand
-        when "list", "ls"
-          list
-        when "create", "new"
-          create(args)
-        when "info"
-          info(args)
-        when "export"
-          export(args)
-        when "import"
-          import(args)
-        when "archive"
-          archive(args)
-        when "restore"
-          restore(args)
-        when "clone", "cp"
-          clone(args)
-        when "delete"
-          delete(args)
-        when "default"
-          set_default(args)
-        else
-          puts "Unknown env command: #{subcommand}"
-          puts
-          help
-          exit 1
-        end
-      end
-
-      def list
-        @manager.setup!
-        envs = @manager.list_with_manifests
-
-        if envs.empty?
-          puts "No environments found."
-          puts "Create one with: prompt_objects env create <name>"
-          return
-        end
-
-        default = @manager.default_environment
-
-        puts "Environments:"
-        puts
-        envs.each do |manifest|
-          default_marker = manifest.name == default ? " (default)" : ""
-          last_opened = manifest.last_opened&.strftime("%Y-%m-%d") || "never"
-          puts "  #{manifest.icon} #{manifest.name}#{default_marker}"
-          puts "    #{manifest.description}" if manifest.description
-          puts "    Last opened: #{last_opened}, Objects: #{manifest.stats['po_count']}"
-          puts
-        end
-      end
-
-      def create(args)
-        name = args.shift
-        unless name
-          puts "Usage: prompt_objects env create <name> [--template <template>]"
-          exit 1
-        end
-
-        template = nil
-        args.each_with_index do |arg, i|
-          if arg == "--template" || arg == "-t"
-            template = args[i + 1]
-          end
-        end
-
-        @manager.setup!
-
-        path = @manager.create(name: name, template: template)
-        puts "Created environment: #{name}"
-        puts "Location: #{path}"
-
-        if @manager.list.size == 1
-          @manager.set_default_environment(name)
-          puts "Set as default environment."
-        end
-      end
-
-      def info(args)
-        name = args.shift || @manager.default_environment
-        unless name
-          puts "Usage: prompt_objects env info <name>"
-          exit 1
-        end
-
-        manifest = @manager.manifest_for(name)
-        unless manifest
-          puts "Environment '#{name}' not found."
-          exit 1
-        end
-
-        path = @manager.environment_path(name)
-        objects = Dir.glob(File.join(path, "objects", "*.md")).map { |f| File.basename(f, ".md") }
-        primitives = Dir.glob(File.join(path, "primitives", "*.rb")).map { |f| File.basename(f, ".rb") }
-
-        puts manifest.info
-        puts
-        puts "  Location: #{path}"
-        puts "  Objects: #{objects.join(', ')}" if objects.any?
-        puts "  Custom primitives: #{primitives.join(', ')}" if primitives.any?
-        puts
-
-        if Env::Git.repo?(path)
-          commits = Env::Git.commit_count(path)
-          dirty = Env::Git.dirty?(path)
-          puts "  Git: #{commits} commits#{dirty ? ' (uncommitted changes)' : ''}"
-        end
-      end
-
-      def export(args)
-        @manager.setup!
-
-        # Parse arguments
-        name = nil
-        output = nil
-
-        i = 0
-        while i < args.length
-          case args[i]
-          when "-o", "--output"
-            output = args[i + 1]
-            i += 1
-          else
-            name ||= args[i]
-          end
-          i += 1
-        end
-
-        # Default to current directory name if no output specified
-        name ||= @manager.default_environment
-        unless name
-          puts "Usage: prompt_objects env export <name> [-o output.poenv]"
-          exit 1
-        end
-
-        unless @manager.environment_exists?(name)
-          puts "Environment '#{name}' not found."
-          exit 1
-        end
-
-        output ||= "#{name}.poenv"
-        env_path = @manager.environment_path(name)
-
-        exporter = Env::Exporter.new(env_path)
-        result = exporter.export(output)
-
-        if result[:success]
-          puts "Exported '#{name}' to: #{result[:path]}"
-          puts
-          puts "Stats:"
-          puts "  Commits: #{result[:stats][:commits]}"
-          puts "  Objects: #{result[:stats][:objects]}"
-          puts "  Primitives: #{result[:stats][:primitives]}"
-        else
-          puts "Export failed: #{result[:error]}"
-          exit 1
-        end
-      end
-
-      def import(args)
-        @manager.setup!
-
-        # Parse arguments
-        bundle_path = nil
-        import_as = nil
-        trust = false
-
-        i = 0
-        while i < args.length
-          case args[i]
-          when "--as"
-            import_as = args[i + 1]
-            i += 1
-          when "--trust"
-            trust = true
-          else
-            bundle_path ||= args[i]
-          end
-          i += 1
-        end
-
-        unless bundle_path
-          puts "Usage: prompt_objects env import <bundle.poenv> [--as <name>] [--trust]"
-          puts
-          puts "Options:"
-          puts "  --as <name>   Import with a different name"
-          puts "  --trust       Trust custom primitives (skip sandbox warnings)"
-          exit 1
-        end
-
-        importer = Env::Importer.new(bundle_path)
-
-        # First, inspect and show what's in the bundle
-        info = importer.inspect_bundle
-        unless info.valid
-          puts "Invalid bundle: #{info.error}"
-          exit 1
-        end
-
-        puts "Bundle contents:"
-        puts "  Name: #{info.name}"
-        puts "  Description: #{info.description}" if info.description
-        puts "  Objects: #{info.objects.join(', ')}" if info.objects.any?
-        puts "  Primitives: #{info.primitives.join(', ')}" if info.primitives.any?
-        puts "  Commits: #{info.commits}"
-        puts
-
-        # Warn about primitives
-        if info.primitives.any? && !trust
-          puts "⚠️  WARNING: This bundle contains custom primitives."
-          puts "Custom primitives can execute arbitrary Ruby code."
-          puts "Review the code before running, or use --trust to skip this warning."
-          puts
-        end
-
-        # Import
-        import_name = import_as || info.name
-        result = importer.import(manager: @manager, name: import_name, trust_primitives: trust)
-
-        if result[:success]
-          puts "Imported as '#{result[:name]}'"
-          puts "Location: #{result[:path]}"
-
-          if result[:warnings].any?
-            puts
-            result[:warnings].each { |w| puts w }
-          end
-        else
-          puts "Import failed: #{result[:error]}"
-          exit 1
-        end
-      end
-
-      def archive(args)
-        name = args.shift
-        unless name
-          puts "Usage: prompt_objects env archive <name>"
-          exit 1
-        end
-
-        path = @manager.archive(name)
-        puts "Archived environment '#{name}' to:"
-        puts "  #{path}"
-      end
-
-      def restore(args)
-        archived_name = args.shift
-        unless archived_name
-          # Show available archived environments
-          archived = @manager.list_archived
-          if archived.empty?
-            puts "No archived environments."
-          else
-            puts "Archived environments:"
-            archived.each { |name| puts "  - #{name}" }
-            puts
-            puts "Usage: prompt_objects env restore <archived_name> [--as <new_name>]"
-          end
-          return
-        end
-
-        restore_as = nil
-        args.each_with_index do |arg, i|
-          restore_as = args[i + 1] if arg == "--as"
-        end
-
-        path = @manager.restore(archived_name, restore_as: restore_as)
-        puts "Restored to: #{path}"
-      end
-
-      def clone(args)
-        source = args.shift
-        target = args.shift
-
-        unless source && target
-          puts "Usage: prompt_objects env clone <source> <target>"
-          exit 1
-        end
-
-        path = @manager.clone(source, target)
-        puts "Cloned '#{source}' to '#{target}'"
-        puts "Location: #{path}"
-      end
-
-      def delete(args)
-        name = args.shift
-        permanent = args.include?("--permanent")
-
-        unless name
-          puts "Usage: prompt_objects env delete <archived_name> --permanent"
-          puts
-          puts "Note: Only archived environments can be permanently deleted."
-          puts "First archive an environment, then delete it."
-          return
-        end
-
-        unless permanent
-          puts "Use --permanent to confirm deletion."
-          puts "This cannot be undone."
-          return
-        end
-
-        @manager.delete_archived(name)
-        puts "Permanently deleted: #{name}"
-      end
-
-      def set_default(args)
-        name = args.shift
-        unless name
-          current = @manager.default_environment
-          if current
-            puts "Current default: #{current}"
-          else
-            puts "No default environment set."
-          end
-          puts
-          puts "Usage: prompt_objects env default <name>"
-          return
-        end
-
-        @manager.set_default_environment(name)
-        puts "Default environment set to: #{name}"
-      end
-
-      def help
-        puts <<~HELP
-          Environment management commands:
-
-            prompt_objects env list              List all environments
-            prompt_objects env create <name>    Create new environment
-              --template, -t <template>         Use template (minimal, developer, writer, empty)
-            prompt_objects env info <name>      Show environment details
-            prompt_objects env export <name>    Export environment as .poenv bundle
-              -o, --output <file>               Output file path
-            prompt_objects env import <file>    Import environment from .poenv bundle
-              --as <name>                       Import with different name
-              --trust                           Trust custom primitives
-            prompt_objects env archive <name>   Archive (soft delete) environment
-            prompt_objects env restore <name>   Restore archived environment
-              --as <new_name>                   Restore with different name
-            prompt_objects env clone <src> <dest>  Clone environment
-            prompt_objects env default <name>   Set default environment
-            prompt_objects env delete <name> --permanent  Delete archived env
-
-          Available templates:
-            basic      - No capabilities, learns as needed (great for demos!)
-            minimal    - Basic assistant with file reading
-            developer  - Code review, debugging, testing specialists
-            writer     - Editor, researcher for content creation
-            empty      - Bootstrap assistant only
-            arc-agi-1  - ARC-AGI-1 challenge solving with grid primitives
-        HELP
+    def self.run(argv)
+      command = argv[0]
+      args = argv[1..] || []
+
+      case command
+      when nil, "help", "--help", "-h"
+        print_main_help
+      when "version", "--version", "-v"
+        puts PromptObjects::VERSION
+      when "env"
+        EnvCommand.new.run(args)
+      when "serve"
+        ServeCommand.new.run(args)
+      when "message", "msg"
+        MessageCommand.new.run(args)
+      when "events"
+        EventsCommand.new.run(args)
+      when "diagnostics", "diag"
+        DiagnosticsCommand.new.run(args)
+      when "explore"
+        ExploreCommand.new.run(args)
+      when "repl"
+        ReplCommand.new.run(args)
+      else
+        # Legacy behavior: treat as repl with name argument
+        ReplCommand.new.run(argv)
       end
     end
 
-    # Parse arguments and run appropriate command.
-    # @param args [Array<String>] Command line arguments
-    # @return [Hash] Parsed options for main command
-    def self.parse(args)
-      options = {
-        env_name: nil,
-        dev_mode: false,
-        sandbox: false,
-        command: :run
-      }
-
-      i = 0
-      while i < args.length
-        arg = args[i]
-        case arg
-        when "env"
-          options[:command] = :env
-          options[:env_args] = args[(i + 1)..]
-          return options
-        when "--env", "-e"
-          options[:env_name] = args[i + 1]
-          i += 1
-        when "--dev"
-          options[:dev_mode] = true
-        when "--sandbox", "-s"
-          options[:sandbox] = true
-        when "--help", "-h"
-          options[:command] = :help
-          return options
-        else
-          # Assume it's a PO name or objects_dir (legacy)
-          options[:legacy_args] ||= []
-          options[:legacy_args] << arg
-        end
-        i += 1
-      end
-
-      options
-    end
-
-    # List available templates.
-    # @return [Array<Hash>] Template info
-    def self.list_templates
-      templates_dir = File.expand_path("../../templates", __dir__)
-      return [] unless Dir.exist?(templates_dir)
-
-      Dir.children(templates_dir).filter_map do |name|
-        manifest_path = File.join(templates_dir, name, "manifest.yml")
-        next unless File.exist?(manifest_path)
-
-        manifest = YAML.safe_load(File.read(manifest_path))
-        {
-          name: name,
-          description: manifest["description"],
-          icon: manifest["icon"]
-        }
-      end
+    def self.print_main_help
+      prog = Helpers.program_name
+      puts <<~HELP
+        Usage: #{prog} <command> [options]
+
+        Commands:
+          env                          Manage environments (create, list, export, etc.)
+          serve <env>                  Run environment as a web server
+          message <env> <po> "text"    Send a message to a PO and print the response
+          events <env> [--session ID]  Show recent events from the message bus
+          diagnostics <env> [--json]   Show content-free runtime health metrics
+          explore [env] [--session ID] Open Thread Explorer to visualize conversations
+          repl [name] [objects_dir]    Start interactive REPL with a prompt object
+          help                         Show this help message
+
+        Run '#{prog} <command> --help' for command-specific help.
+
+        Examples:
+          #{prog} env list                     # List all environments
+          #{prog} env create demo --template basic  # Create from template
+          #{prog} serve my-env                 # Start web UI
+          #{prog} serve my-env --open          # Start and open browser
+          #{prog} message my-env solver "Hello"     # Send a message
+          #{prog} message my-env solver "Hello" --json  # JSON output
+          #{prog} explore my-env                  # Visualize conversations
+      HELP
     end
   end
 end

data/lib/prompt_objects/connectors/base.rb

@@ -36,38 +36,25 @@ module PromptObjects
         raise NotImplementedError, "#{self.class} must implement #source_name"
       end
 
-      protected
-
-      # Helper to get or create a session for a PO with source tracking
-      # @param po [PromptObject] The prompt object
-      # @param session_name [String, nil] Optional session name
-      # @return [String] Session ID
-      def get_or_create_session(po, session_name: nil)
-        return nil unless runtime.session_store
-
-        # Check if PO already has a session
-        session_id = po.instance_variable_get(:@session_id)
-        return session_id if session_id
-
-        # Create new session with source tracking
-        session_id = runtime.session_store.create_session(
-          po_name: po.name,
-          name: session_name || "#{source_name.upcase} Session #{Time.now.strftime('%H:%M')}",
-          source: source_name
+      # Route an inbound external event to a PO through the unified entry point.
+      # The message is tagged with this connector's source, so its provenance
+      # shows up in the timeline (e.g. "← discord"). This is how a Discord/Slack/
+      # webhook connector forwards an incoming message to a Prompt-Object.
+      # @param target_po [String] PO to deliver to
+      # @param content [String] Message content
+      # @return [String] The PO's response
+      def inject(target_po:, content:, workspace_session_id: nil,
+                 thread_id: nil, client_request_id: nil)
+        runtime.inject_message(
+          target_po: target_po,
+          content: content,
+          from_source: "service:#{source_name}",
+          workspace_session_id: workspace_session_id,
+          thread_id: thread_id,
+          client_request_id: client_request_id
         )
-
-        # Attach to PO
-        po.instance_variable_set(:@session_id, session_id)
-        session_id
       end
 
-      # Update last_message_source when a message is sent
-      # @param session_id [String] Session ID
-      def update_session_source(session_id)
-        return unless runtime.session_store && session_id
-
-        runtime.session_store.update_session(session_id, last_message_source: source_name)
-      end
     end
   end
 end