plasma-mcp 0.0.1

data/lib/plasma/cli.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+require "zeitwerk"
+
+module Plasma
+  # CLI interface for the plasma-mcp gem
+  class CLI < Thor
+    desc "new NAME", "Create a new MCP server project"
+    method_option :skip_git, type: :boolean, default: false, desc: "Skip Git initialization"
+    def new(name)
+      generator = Generator.new(name, options)
+      generator.generate
+
+      return if options[:skip_git]
+
+      Dir.chdir(name) do
+        system("git init .")
+      end
+    end
+
+    desc "server [/path/to/your/plasma/project]", "Launch your MCP server from the specified project path"
+    def server(path = nil)
+      # Change to the specified path if provided
+      Dir.chdir(path) if path
+
+      # Start the server
+      server = Server.new(options)
+      server.start
+    end
+
+    # Alias for server
+    map "s" => :server
+
+    desc "auth", "Launch the local authentication beacon"
+    method_option :port, type: :numeric, desc: "Port to run the auth server on"
+    method_option :host, type: :string, desc: "Host to bind the auth server to"
+    def auth
+      puts "Engaging local authentication system..."
+
+      # Start the auth server with options
+      auth = Auth.new(options)
+      auth.start
+    end
+
+    desc "console", "Start an interactive console with your PLASMA application loaded"
+    def console
+      require "debug"
+
+      # Load the application so we can use it in the console if we need to
+      require_relative "loader"
+      _application = Plasma::Loader.load_project
+
+      # Start an interactive console
+      binding.irb # rubocop:disable Lint/Debugger
+    end
+
+    desc "version", "Show PLASMA version"
+    def version
+      puts "PLASMA version #{Plasma::VERSION}"
+    end
+
+    # Generator commands
+    desc "generate TYPE NAME [PARAMETERS]", "Generate a new component (tool, prompt, resource, or variable)"
+    def generate(type, name, *parameters)
+      # Parse parameters into a hash
+      params = {}
+      parameters.each do |param|
+        key, value = param.split(":")
+        params[key] = value if key && value
+      end
+
+      # Create the generator
+      generator = ComponentGenerator.new(type, name, params)
+      generator.generate
+    end
+
+    # Alias for generate
+    map "g" => :generate
+
+    private
+
+    def plasma_project?
+      File.exist?("config/application.rb") &&
+        File.exist?("config/boot.rb") &&
+        Dir.exist?("app/prompts") &&
+        Dir.exist?("app/resources") &&
+        Dir.exist?("app/tools") &&
+        Dir.exist?("app/variables")
+    end
+  end
+end

data/lib/plasma/component_generator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "erb"
+require "active_support/inflector"
+require "json"
+
+module Plasma
+  # Handles generating individual MCP components (tools, prompts, resources, variables)
+  class ComponentGenerator
+    attr_reader :component_type, :name, :params
+
+    def initialize(component_type, name, params = {})
+      @component_type = component_type
+      @name = name
+      @params = params
+      @template_dir = File.expand_path("templates", __dir__)
+      puts "Template directory: #{@template_dir}"
+    end
+
+    def generate
+      # Check if we're in a PLASMA project directory
+      unless plasma_project?
+        puts "Error: Not a PLASMA project directory. Please run this command from the root of a PLASMA project."
+        return false
+      end
+
+      create_component_file
+      true
+    end
+
+    private
+
+    def plasma_project?
+      File.exist?("config/application.rb") &&
+        File.exist?("config/boot.rb") &&
+        Dir.exist?("app/prompts") &&
+        Dir.exist?("app/resources") &&
+        Dir.exist?("app/tools") &&
+        Dir.exist?("app/variables")
+    end
+
+    def create_component_file
+      template_path = find_template_path
+      content = render_template(template_path)
+      write_component_file(content)
+    end
+
+    def find_template_path
+      path = File.join(@template_dir, "app", "#{@component_type}s", "example_#{@component_type}.rb.erb")
+      raise "Template not found at: #{path}" unless File.exist?(path)
+
+      path
+    end
+
+    def render_template(template_path)
+      template = ERB.new(File.read(template_path), trim_mode: "-")
+      template.result(binding)
+    end
+
+    def write_component_file(content)
+      component_dir = File.join("app", "#{@component_type}s")
+      FileUtils.mkdir_p(component_dir)
+
+      file_path = File.join(component_dir, "#{@name.downcase}_#{@component_type}.rb")
+      File.write(file_path, content)
+    end
+
+    def module_name
+      # Get the application module name from the current directory
+      File.basename(Dir.pwd).gsub("-", "_").camelize
+    end
+
+    def parameter_schema
+      return {} if params.empty?
+
+      schema = {
+        type: "object",
+        properties: params.transform_values { |type| { type: type } },
+        required: params.keys
+      }
+
+      JSON.pretty_generate(schema)
+    end
+
+    # Convert the name to the appropriate format for the file
+    def file_name
+      # Convert camelCase to snake_case and append _tool
+      "#{@name.underscore}_#{@component_type}"
+    end
+
+    # Convert the name to kebab-case for the metadata
+    def kebab_name
+      @name.underscore.gsub("_", "-")
+    end
+
+    def component_class_name
+      @name.split("_").map(&:capitalize).join
+    end
+
+    def component_name
+      @name.downcase
+    end
+
+    def parameter_definitions
+      @params.map do |name, type|
+        "#{name}: { type: \"#{type}\" }"
+      end.join(",\n    ")
+    end
+  end
+end

data/lib/plasma/generator.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "erb"
+require "active_support/inflector"
+
+module Plasma
+  # Handles generating new MCP server projects from templates
+  class Generator
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+    end
+
+    def generate
+      create_project_directory
+      create_directory_structure
+      generate_files_from_templates
+      copy_static_files
+      move_version_file
+    end
+
+    private
+
+    def create_project_directory
+      FileUtils.mkdir_p(name)
+    end
+
+    def create_directory_structure
+      dirs = %w[app/prompts app/resources app/tools app/variables app/records
+                config/initializers lib .github/workflows]
+
+      dirs.each do |dir|
+        dir_path = File.join(name, dir)
+        FileUtils.mkdir_p(dir_path)
+        FileUtils.touch(File.join(dir_path, ".gitkeep"))
+      end
+    end
+
+    def templates_dir
+      File.expand_path("templates", __dir__)
+    end
+
+    def move_version_file
+      # Create the namespace directory
+      namespace_dir = File.join(name, "lib", name.underscore)
+      FileUtils.mkdir_p(namespace_dir)
+
+      # Move the version file to the correct location
+      version_file = File.join(name, "lib/version.rb")
+      new_version_file = File.join(namespace_dir, "version.rb")
+      return unless File.exist?(version_file)
+
+      FileUtils.mv(version_file, new_version_file)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def generate_files_from_templates
+      # Exclude example component templates and include dot files
+      template_files = Dir.glob(File.join(templates_dir, "**", "*.erb"), File::FNM_DOTMATCH).reject do |file|
+        result = file.include?("/app/") && file.include?("example_")
+        result
+      end
+
+      template_files.each do |template_path|
+        # Get relative path from templates directory
+        relative_path = template_path.sub("#{templates_dir}/", "")
+        # Remove .erb extension
+        output_path = relative_path.sub(/\.erb$/, "")
+        # Replace placeholder with actual project name
+        output_path = output_path.gsub("PROJECT_NAME", name)
+
+        # Create full path for destination
+        dest_path = File.join(name, output_path)
+
+        # Ensure directory exists
+        FileUtils.mkdir_p(File.dirname(dest_path))
+
+        # Render the template
+        template = ERB.new(File.read(template_path))
+        result = template.result(binding)
+
+        # Write file
+        File.write(dest_path, result)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    # rubocop:disable Metrics/AbcSize
+    def copy_static_files
+      static_files = Dir.glob(File.join(templates_dir, "**", "*"), File::FNM_DOTMATCH).reject do |file|
+        File.directory?(file) || file.end_with?(".erb")
+      end
+
+      static_files.each do |file_path|
+        relative_path = file_path.sub("#{templates_dir}/", "")
+        dest_path = File.join(name, relative_path.gsub("PROJECT_NAME", name))
+
+        FileUtils.mkdir_p(File.dirname(dest_path))
+        FileUtils.cp(file_path, dest_path)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def module_name
+      name.gsub("-", "_").camelize
+    end
+  end
+end
+
+# Add extension methods for string transformations in ERB templates
+class String
+  unless method_defined?(:camelize)
+    def camelize
+      ActiveSupport::Inflector.camelize(self)
+    end
+  end
+
+  unless method_defined?(:underscore)
+    def underscore
+      ActiveSupport::Inflector.underscore(self)
+    end
+  end
+
+  unless method_defined?(:dasherize)
+    def dasherize
+      ActiveSupport::Inflector.dasherize(self)
+    end
+  end
+end

data/lib/plasma/loader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Plasma
+  # Handles loading PLASMA projects
+  class Loader
+    def self.load_project
+      # Load the application boot file
+      require_relative File.join(Dir.pwd, "config/boot")
+
+      # Determine the application class name
+      app_name = File.basename(Dir.pwd).gsub("-", "_").camelize
+
+      # Load the application
+      require_relative File.join(Dir.pwd, "config/application")
+
+      # Get the application module and include it in the top-level scope
+      app_module = Object.const_get(app_name)
+      Object.include(app_module)
+
+      # Return the application class
+      Object.const_get("#{app_name}::Application")
+    rescue LoadError, NameError => e
+      handle_load_error(e)
+    end
+
+    def self.handle_load_error(error)
+      message = error.is_a?(LoadError) ? "Error loading application" : "Error initializing application"
+      puts "#{message}: #{error.message}"
+      raise error
+    end
+  end
+end

data/lib/plasma/prompt.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "model_context_protocol"
+
+module Plasma
+  # Base prompt class for PLASMA applications
+  class Prompt < ModelContextProtocol::Server::Prompt
+    # For now, this defers to the base class for everything
+  end
+end

data/lib/plasma/resource.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "model_context_protocol"
+
+module Plasma
+  # Base resource class for PLASMA applications
+  class Resource < ModelContextProtocol::Server::Resource
+    # Required by MCP - defines the resource schema
+    # rubocop:disable Metrics/MethodLength
+    def self.schema
+      {
+        name: name.underscore,
+        description: "Base resource for PLASMA applications",
+        content_schema: {
+          type: "object",
+          properties: {
+            id: { type: "string" }
+          },
+          required: ["id"]
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Required by MCP - defines the resource content
+    def content
+      {
+        id: id
+      }
+    end
+
+    attr_reader :id
+
+    def initialize(id:)
+      @id = id
+      super
+    end
+  end
+end

data/lib/plasma/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "model_context_protocol"
+
+module Plasma
+  # Handles MCP server operations
+  class Server
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def start
+      # Check if we're in a PLASMA project directory
+      unless plasma_project?
+        puts "Error: Not a PLASMA project directory. Please run this command from the root of a PLASMA project."
+        return false
+      end
+
+      # Load the application
+      app_class = load_application
+
+      # Start the MCP server
+      app_class.start_server
+
+      true
+    rescue Interrupt
+      # puts "\nShutting down MCP server..."
+    end
+
+    private
+
+    def plasma_project?
+      File.exist?("config/application.rb") &&
+        File.exist?("config/boot.rb") &&
+        Dir.exist?("app/prompts") &&
+        Dir.exist?("app/resources") &&
+        Dir.exist?("app/tools")
+    end
+
+    def load_application
+      require_relative "loader"
+      Plasma::Loader.load_project
+    end
+  end
+end

data/lib/plasma/storage/application_record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Plasma
+  module Storage
+    # Base class for all application models
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/lib/plasma/storage/record.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plasma
+  module Storage
+    # Model for storing serialized data with automatic JSON parsing
+    class Record < ApplicationRecord
+      class << self
+        def inherited(subclass)
+          super
+          const_name = subclass.to_s.split("::").last
+          Plasma.const_set(const_name, subclass) unless Plasma.const_defined?(const_name)
+        end
+      end
+    end
+  end
+end

data/lib/plasma/storage/variable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Plasma
+  module Storage
+    # Model for storing key-value pairs with automatic JSON parsing
+    class Variable < ApplicationRecord
+      self.primary_key = "key"
+
+      serialize :value do |val|
+        case val
+        when String
+          begin
+            JSON.parse(val)
+          rescue JSON::ParserError
+            val
+          end
+        when Hash, Array
+          val
+        else
+          val.to_s
+        end
+      end
+
+      class << self
+        attr_accessor :default_value
+
+        def inherited(subclass)
+          super
+          const_name = subclass.to_s.split("::").last
+          Plasma.const_set(const_name, subclass) unless Plasma.const_defined?(const_name)
+        end
+
+        def key
+          name.demodulize.underscore
+        end
+
+        def set(value)
+          raise "Failed to set value for #{key}" unless create_or_find_by(key: key).update(value: value)
+
+          value
+        end
+
+        def get
+          find_by(key: key)&.value || default_value
+        end
+
+        def default(value)
+          @default_value = value
+        end
+      end
+    end
+  end
+end

data/lib/plasma/storage.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "sqlite3"
+
+# Load all models
+Dir[File.join(__dir__, "storage", "*.rb")].each { |file| require file }
+
+module Plasma
+  # This module handles the storage operations for PLASMA applications
+  module Storage
+    # rubocop:disable Metrics/MethodLength
+    def self.define_default_schema
+      ActiveRecord::Schema.define(verbose: false) do
+        create_table :records do |t|
+          t.json :data
+          t.timestamps
+        end
+
+        create_table :variables, id: false do |t|
+          t.string :key, primary_key: true
+          t.json :value
+        end
+
+        create_table :settings do |t|
+          t.string :group, null: false
+          t.json :data
+          t.timestamps
+        end
+
+        add_index :settings, :group, unique: true
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.setup
+      establish_connection
+      load_schema
+    end
+
+    def self.establish_connection
+      ActiveRecord::Base.establish_connection(
+        adapter: "sqlite3",
+        database: ":memory:"
+      )
+      ActiveRecord::Migration.verbose = false
+    end
+
+    def self.load_schema
+      schema_path = File.join(Dir.pwd, "db", "schema.rb")
+      if File.exist?(schema_path)
+        load schema_path
+      else
+        define_default_schema
+      end
+    end
+
+    def self.add_record(fields = {})
+      Plasma::Storage::Record.create(data: fields)
+    end
+
+    def self.find_records
+      Plasma::Storage::Record.all.map { |r| r.data.merge(id: r.id, created_at: r.created_at) }
+    end
+
+    def self.find_records_by_field(field, value)
+      Plasma::Storage::Record.all.select { |r| r.data[field.to_s] == value || r.data[field.to_sym] == value }
+                             .map { |r| r.data.merge(id: r.id, created_at: r.created_at) }
+    end
+
+    def self.find_records_with_field(field)
+      records = Plasma::Storage::Record.all
+      filtered = records.select { |r| r.data.key?(field.to_s) || r.data.key?(field.to_sym) }
+      filtered.map { |r| r.data.merge(id: r.id, created_at: r.created_at) }
+    end
+
+    def self.update_record_field(id, field, value)
+      record = Plasma::Storage::Record.find(id)
+      record.data[field] = value
+      record.save!
+    end
+
+    def self.set_var(key, value)
+      Plasma::Storage::Variable.create_or_find_by(key: key).update(value: value)
+    end
+
+    def self.get_var(key)
+      Plasma::Storage::Variable.find_by(key: key)&.value
+    end
+
+    def self.dump_to_json
+      {
+        records: find_records,
+        variables: Plasma::Storage::Variable.all.pluck(:key, :value).to_h
+      }.to_json
+    end
+  end
+end
+
+# Setup database when module is loaded
+Plasma::Storage.setup

data/lib/plasma/templates/.dockerignore.erb

@@ -0,0 +1,40 @@
+# Git
+.git
+.gitignore
+
+# Ruby
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Logs
+*.log
+
+# Editor directories and files
+.idea
+.vscode
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db

data/lib/plasma/templates/.env.erb

@@ -0,0 +1,2 @@
+# Environment variables
+PLASMA_ENV=development