plasma-mcp 0.0.1

data/lib/plasma/templates/.github/workflows/docker-build.yml.erb

@@ -0,0 +1,52 @@
+name: Build and Publish Multi-Arch Docker Image
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'lib/**/version.rb'
+    tags:
+      - 'v*'  # Trigger on all semver-like tags: v1.2.3, v1.2.3-rc.1
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Extract version from version.rb
+        id: version
+        run: |
+          VERSION=$(ruby -e "require_relative 'lib/<%= name %>/version'; puts <%= name.camelize %>::VERSION")
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+          if [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "IS_STABLE=true" >> $GITHUB_ENV
+          else
+            echo "IS_STABLE=false" >> $GITHUB_ENV
+          fi
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push multi-arch Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            ghcr.io/${{ github.repository }}:v${{ env.VERSION }}
+            ${{ env.IS_STABLE == 'true' && format('ghcr.io/{0}:latest', github.repository) || '' }}

data/lib/plasma/templates/.gitignore.erb

@@ -0,0 +1,40 @@
+# 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
+
+# Docker
+.docker/
+docker-compose.override.yml

data/lib/plasma/templates/.ruby-version.erb

@@ -0,0 +1 @@
+3.4.3

data/lib/plasma/templates/Dockerfile.erb

@@ -0,0 +1,18 @@
+FROM ruby:3.4.3-slim
+
+WORKDIR /<%= name %>
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies
+COPY Gemfile Gemfile.lock ./
+RUN bundle install
+
+# Copy application code
+COPY . .
+
+# Command to run the application
+CMD ["bundle", "exec", "plasma", "server"]

data/lib/plasma/templates/Gemfile.erb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "plasma-mcp", "~> <%= Plasma::VERSION %>"
+gem "dotenv", "~> 2.8"

data/lib/plasma/templates/README.md.erb

@@ -0,0 +1,228 @@
+# <%= name.camelize %> MCP Server
+
+This is a Model Context Protocol (MCP) server built with `plasma-mcp` framework.
+
+## Using with Claude
+
+To use this MCP server with Claude, add the following configuration to your Claude settings:
+
+```json
+{
+  "mcpServers": {
+    "<%= name.underscore %>": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "ghcr.io/your-org/<%= name.underscore %>:latest"
+      ]
+    }
+  }
+}
+```
+
+For local development without Docker:
+
+```json
+{
+  "mcpServers": {
+    "<%= name.underscore %>": {
+      "command": "plasma",
+      "args": [
+        "server",
+        "/path/to/<%= name.underscore %>"
+      ]
+    }
+  }
+}
+```
+
+## Using with VS Code
+
+Add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open User Settings (JSON)`.
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "<%= name.underscore %>": {
+        "command": "docker",
+        "args": [
+          "run",
+          "-i",
+          "--rm",
+          "ghcr.io/your-org/<%= name.underscore %>:latest"
+        ]
+      }
+    }
+  }
+}
+```
+
+Optionally, you can add a similar example (i.e. without the `mcp` key) to a file called `.vscode/mcp.json` in your workspace. This will allow you to share the configuration with others.
+
+```json
+{
+  "servers": {
+    "<%= name.underscore %>": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "ghcr.io/your-org/<%= name.underscore %>:latest"
+      ]
+    }
+  }
+}
+```
+
+For local development without Docker:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "<%= name.underscore %>": {
+        "command": "plasma",
+        "args": [
+          "server",
+          "/path/to/<%= name.underscore %>"
+        ]
+      }
+    }
+  }
+}
+```
+
+More about using MCP server tools in VS Code's [agent mode documentation](https://code.visualstudio.com/docs/editor/agent-mode).
+
+## Setup
+
+1. Install dependencies:
+
+```bash
+bundle install
+```
+
+2. Configure environment variables in `.env` file
+
+## Running the Server
+
+To start the MCP server:
+
+```bash
+plasma server
+```
+
+## Authentication
+
+To run the local authentication system:
+
+```bash
+plasma auth
+```
+
+## Project Structure
+
+```
+<%= name %>/
+├── app/
+│   ├── prompts/        # MCP prompts
+│   ├── resources/      # MCP resources
+│   ├── tools/          # MCP tools
+│   ├── variables/      # Per-session variables
+│   └── records/        # Stored objects
+├── config/
+│   ├── initializers/   # Preload configuration
+│   ├── application.rb  # MCP server configuration
+│   └── boot.rb         # Launch ignition sequence
+└── .env                # Environment variables
+```
+
+## Adding New Components
+
+### Adding a new Tool
+
+Generate a new tool using the CLI:
+
+```bash
+plasma g tool my_tool name:string description:string
+```
+
+This will generate a tool file in `app/tools/my_tool.rb` that follows this structure:
+
+```ruby
+# app/tools/my_tool.rb
+module <%= name.camelize %>
+  module Tools
+    class MyTool < Plasma::Tool
+      param :name,
+            type: :string,
+            description: "Name parameter description"
+
+      param :description,
+            type: :string,
+            description: "Description parameter description"
+
+      def call
+        respond_with(:text,
+          text: "Your tool response here"
+        )
+      end
+    end
+  end
+end
+```
+
+### Adding a new Prompt
+
+Generate a new prompt using the CLI:
+
+```bash
+plasma g prompt my_prompt
+```
+
+This will generate a prompt file in `app/prompts/my_prompt.rb`:
+
+```ruby
+# app/prompts/my_prompt.rb
+module <%= name.camelize %>
+  module Prompts
+    class MyPrompt
+      def self.system_prompt
+        <<~PROMPT
+          Your system prompt content here.
+        PROMPT
+      end
+    end
+  end
+end
+```
+
+### Adding a new Resource
+
+Generate a new resource using the CLI:
+
+```bash
+plasma g resource my_resource
+```
+
+### Adding a new Variable
+
+Generate a new variable using the CLI:
+
+```bash
+plasma g variable my_variable
+```
+
+## Interactive Console
+
+To start an interactive console with your plasma-mcp application loaded:
+
+```bash
+plasma console
+```
+
+This will give you access to your project's environment where you can interact with your components, storage variables, and other features.

data/lib/plasma/templates/app/prompts/example_prompt.rb.erb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  module Prompts
+    class <%= name.camelize %> < Plasma::Prompt
+      # Define the system prompt content
+      with_metadata do
+        {
+          name: "<%= name.underscore %>",
+          description: "A <%= name.underscore %> prompt",
+          arguments: <%= parameters.map { |name, type| { name: name, description: "The #{name} parameter", required: true } }.to_json %>
+        }
+      end
+
+      def call
+        messages = [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: "Process these parameters: <%= parameters.keys.map { |p| "#{p}: #{p}" }.join(", ") %>"
+            }
+          }
+        ]
+
+        MessageResponse[message: messages]
+      end
+    end
+  end
+end

data/lib/plasma/templates/app/resources/example_resource.rb.erb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  module Resources
+    class <%= name.camelize %> < Plasma::Resource
+      # Required by MCP - defines the resource schema
+      with_metadata do
+        {
+          name: "<%= name.underscore %>",
+          description: "A <%= name.underscore %> resource",
+          content_schema: <%= parameter_schema.to_json %>
+        }
+      end
+
+      # Required by MCP - defines the resource content
+      def content
+        {
+          id: id,
+          <%= parameters.map { |name, type| "#{name}: #{name}" }.join(",\n          ") %>
+        }
+      end
+
+      attr_reader :id<%= parameters.map { |name, type| ", :#{name}" }.join %>
+
+      def initialize(id:, <%= parameters.map { |name, type| "#{name}:" }.join(", ") %>)
+        @id = id
+        <%= parameters.map { |name, type| "@#{name} = #{name}" }.join("\n        ") %>
+        super
+      end
+
+      def call
+        TextResponse[text: "Here's the data"]
+      end
+    end
+  end
+end

data/lib/plasma/templates/app/tools/example_tool.rb.erb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  module Tools
+    # A <%= kebab_name %> tool
+    class <%= name.camelize %>Tool < Plasma::Tool
+      <% params.each do |name, type| %>
+      param :<%= name %>, type: <%= type.capitalize %>, description: "<%= name.capitalize %> parameter", required: true
+      <% end %>
+
+      # Required, implements the tool functionality
+      def call
+        # Example of different response types:
+
+        # Text response with parameters
+        respond_with(:text, text: "Hello from <%= name.camelize %>Tool with params: <% params.each do |name, type| %>#{params[:<%= name %>]} <% end %>")
+
+        # Image response with mime type
+        # respond_with(:image, data: image_data, mime_type: "image/png")
+
+        # Image response without mime type
+        # respond_with(:image, data: image_data)
+
+        # Resource response with mime type
+        # respond_with(:resource, mime_type: "text/html", text: "Resource content", uri: "https://example.com")
+
+        # Resource response without mime type
+        # respond_with(:resource, text: "Resource content", uri: "https://example.com")
+
+        # Error response
+        # respond_with(:error, text: "An error occurred")
+      end
+    end
+  end
+end

data/lib/plasma/templates/app/variables/example_variable.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  module Variables
+    # A <%= name.underscore %> variable
+    class <%= name.camelize %> < Plasma::Storage::Variable
+      default <%= default_value %>
+
+      <% operations.each do |op| %>
+      def self.<%= op[:name] %>(<%= op[:params].join(", ") %>)
+        self.set(self.get <%= op[:operator] %> <%= op[:params].first %>)
+      end
+      <% end %>
+
+      def self.clear
+        self.set(<%= default_value %>)
+      end
+    end
+  end
+end

data/lib/plasma/templates/config/application.rb.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "plasma"
+require_relative "../lib/<%= name %>/version"
+
+module <%= name.camelize %>
+  class Application < Plasma::Application
+    # Configure your application here
+    self.initialize! do |config|
+      # Name will be automatically set as "<%= name.camelize %> MCP Server" if not set
+      # config.name = "Custom Application Name"
+      config.module_name = "<%= name.camelize %>"
+
+      config.version = <%= name.camelize %>::VERSION
+      config.enable_log = true
+
+      # Example of requiring an environment variable (uncomment to use)
+      # config.require_environment_variable("API_KEY")
+
+      # Example of setting an environment variable (uncomment to use)
+      # config.set_environment_variable("DEBUG_MODE", "true")
+    end
+  end
+end

data/lib/plasma/templates/config/boot.rb.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Initial ignition sequence
+require "bundler/setup"
+Bundler.require(:default, ENV["PLASMA_ENV"] || "development")
+
+# Load environment variables from .env file
+require "dotenv"
+Dotenv.load
+
+# Load initializers
+Dir[File.join(__dir__, "initializers/**/*.rb")].sort.each { |f| require f }

data/lib/plasma/templates/config/initializers/example.rb.erb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# This is an example initializer file.
+# Initializers are loaded after the application boots and can be used to
+# configure your MCP server or set up any necessary dependencies.
+
+# Add your initialization code here

data/lib/plasma/templates/lib/version.rb.erb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module <%= name.camelize %>
+  VERSION = "0.0.1"
+end

data/lib/plasma/tool.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "model_context_protocol"
+require "json"
+
+module Plasma
+  # Base tool class for PLASMA applications
+  class Tool < ModelContextProtocol::Server::Tool
+    class << self
+      def param(name, type:, description: nil, required: false)
+        @params ||= {}
+        @params[name.to_sym] = {
+          type: type.to_s.downcase,
+          description:,
+          required:
+        }
+      end
+
+      def defined_params
+        @params || {}
+      end
+
+      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 metadata
+        {
+          name: to_s.split("::").last.gsub("Tool", "").underscore,
+          description: extract_description,
+          inputSchema: {
+            type: "object",
+            properties: defined_params.transform_values { |v| v.slice(:type, :description).compact },
+            required: defined_params.select { |_, v| v[:required] }.keys.map(&:to_s)
+          }
+        }
+      end
+
+      def extract_description
+        return @description if @description
+
+        @description = read_comments_from_file(file_path).presence || "No description available"
+      end
+
+      def file_path
+        loader = Zeitwerk::Registry.loaders.first
+        module_name = to_s.split("::")[0..-2].join("::").constantize
+        class_name = to_s.split("::").last.to_sym
+        path = loader.instance_variable_get(:@inceptions).instance_variable_get(:@map)[module_name][class_name]
+        return nil unless path
+
+        File.expand_path(path)
+      end
+
+      def read_comments_from_file(file_path)
+        return "No description available" unless file_path
+
+        File.readlines(file_path)
+            .drop_while { |line| line.include?("frozen_string_literal") || line.strip.empty? }
+            .drop_while { |line| line.strip.start_with?("module") }
+            .take_while { |line| line.strip.start_with?("#") }
+            .join
+            .strip
+            .gsub(/^#\s*/, "")
+      end
+    end
+
+    # rubocop:disable Lint/MissingSuper
+    # DO NOT call super as we are deliberately decoupling the tool from the underlying library
+    def initialize(params)
+      @raw_params = params
+      @params = coerce_and_validate!(params)
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    attr_reader :params
+
+    private
+
+    def coerce_and_validate!(input)
+      coerced = {}
+      self.class.defined_params.each do |key, config|
+        value = input[key.to_s]
+        raise ArgumentError, "Missing required parameter: #{key}" if config[:required] && value.nil?
+
+        coerced[key] = coerce_value(value, config[:type])
+      end
+      coerced
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # This method is deliberately complex as it handles type coercion and validation
+    def coerce_value(value, type)
+      return if value.nil?
+
+      case type.to_s.downcase.to_sym
+      when :integer then begin
+        Integer(value)
+      rescue StandardError
+        raise ArgumentError, "Invalid integer: #{value}"
+      end
+      when :float then begin
+        Float(value)
+      rescue StandardError
+        raise ArgumentError, "Invalid float: #{value}"
+      end
+      when :boolean then !!(value == true || value.to_s.downcase == "true")
+      when :string  then value.to_s
+      when :array
+        if value.is_a?(Array)
+          value
+        elsif value.is_a?(String)
+          begin
+            parsed = JSON.parse(value)
+            raise ArgumentError, "Invalid array: #{value}" unless parsed.is_a?(Array)
+
+            parsed
+          rescue JSON::ParserError
+            raise ArgumentError, "Invalid array: #{value}"
+          end
+        else
+          raise ArgumentError, "Invalid array: #{value}"
+        end
+      else value
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/plasma/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Plasma
+  VERSION = "0.0.1"
+end

data/lib/plasma.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "plasma/version"
+require_relative "plasma/application"
+require_relative "plasma/generator"
+require_relative "plasma/component_generator"
+require_relative "plasma/server"
+require_relative "plasma/auth"
+require_relative "plasma/loader"
+require_relative "plasma/cli"
+require_relative "plasma/prompt"
+require_relative "plasma/resource"
+require_relative "plasma/tool"
+require_relative "plasma/storage"
+
+module Plasma
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/plasma.rbs

@@ -0,0 +1,4 @@
+module Plasma
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end