vsm 0.0.1 → 0.2.0

data/lib/vsm/drivers/gemini/async_driver.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require "async"
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+
+module VSM
+  module Drivers
+    module Gemini
+      class AsyncDriver
+        def initialize(api_key:, model:, base_url: "https://generativelanguage.googleapis.com/v1beta", streaming: true)
+          @api_key, @model, @base, @streaming = api_key, model, base_url, streaming
+        end
+
+        def run!(conversation:, tools:, policy: {}, &emit)
+          contents = to_gemini_contents(conversation)
+          fndecls  = normalize_gemini_tools(tools)
+          if @streaming
+            uri = URI.parse("#{@base}/models/#{@model}:streamGenerateContent?alt=sse&key=#{@api_key}")
+            headers = { "content-type" => "application/json", "accept" => "text/event-stream" }
+            body = JSON.dump({ contents: contents, system_instruction: (policy[:system_prompt] && { parts: [{ text: policy[:system_prompt] }], role: "user" }), tools: [{ functionDeclarations: fndecls }] })
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = (uri.scheme == "https")
+            req = Net::HTTP::Post.new(uri.request_uri)
+            headers.each { |k,v| req[k] = v }
+            req.body = body
+            http.request(req) do |res|
+              if res.code.to_i != 200
+                err = +""; res.read_body { |c| err << c }
+                emit.call(:assistant_final, "Gemini HTTP #{res.code}: #{err.to_s.byteslice(0, 400)}")
+                next
+              end
+              buffer = +""; text = +""; calls = []
+              res.read_body do |chunk|
+                buffer << chunk
+                while (i = buffer.index("\n"))
+                  line = buffer.slice!(0..i)
+                  line.chomp!
+                  next unless line.start_with?("data:")
+                  data = line.sub("data:","").strip
+                  next if data.empty? || data == "[DONE]"
+                  obj = JSON.parse(data) rescue nil
+                  next unless obj
+                  parts = (obj.dig("candidates",0,"content","parts") || [])
+                  parts.each do |p|
+                    if (t = p["text"]) && !t.empty?
+                      text << t
+                      emit.call(:assistant_delta, t)
+                    end
+                    if (fc = p["functionCall"]) && fc["name"]
+                      calls << { id: SecureRandom.uuid, name: fc["name"], arguments: (fc["args"] || {}) }
+                    end
+                  end
+                end
+              end
+              if calls.any?
+                emit.call(:tool_calls, calls)
+              else
+                emit.call(:assistant_final, text)
+              end
+            end
+          else
+            uri = URI.parse("#{@base}/models/#{@model}:generateContent?key=#{@api_key}")
+            headers = { "content-type" => "application/json" }
+            body = JSON.dump({ contents: contents, system_instruction: (policy[:system_prompt] && { parts: [{ text: policy[:system_prompt] }], role: "user" }), tools: [{ functionDeclarations: fndecls }] })
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = (uri.scheme == "https")
+            req = Net::HTTP::Post.new(uri.request_uri)
+            headers.each { |k,v| req[k] = v }
+            req.body = body
+            res = http.request(req)
+            if res.code.to_i != 200
+              emit.call(:assistant_final, "Gemini HTTP #{res.code}")
+            else
+              data = JSON.parse(res.body) rescue {}
+              parts = (data.dig("candidates",0,"content","parts") || [])
+              calls = parts.filter_map { |p| fc = p["functionCall"]; fc && { id: SecureRandom.uuid, name: fc["name"], arguments: fc["args"] || {} } }
+              if calls.any?
+                emit.call(:tool_calls, calls)
+              else
+                text = parts.filter_map { |p| p["text"] }.join
+                emit.call(:assistant_final, text.to_s)
+              end
+            end
+          end
+          :done
+        end
+
+        private
+        # (no IPv6/IPv4 forcing; rely on default Internet)
+        def normalize_gemini_tools(tools)
+          Array(tools).map { |t| normalize_gemini_tool(t) }
+        end
+
+        def normalize_gemini_tool(t)
+          return t.to_gemini_tool if t.respond_to?(:to_gemini_tool)
+
+          # Provider-shaped: { name:, description:, parameters: {…} }
+          if t.is_a?(Hash) && (t[:parameters] || t["parameters"])
+            return t
+          end
+
+          # Neutral hash {name:, description:, schema:}
+          if t.is_a?(Hash) && (t[:name] || t["name"])
+            return {
+              name:        t[:name]        || t["name"],
+              description: t[:description] || t["description"] || "",
+              parameters:  t[:schema]      || t["schema"]      || {}
+            }
+          end
+
+          raise TypeError, "unsupported tool descriptor: #{t.inspect}"
+        end
+
+
+        def to_gemini_contents(neutral)
+          items = []
+          neutral.each do |m|
+            case m[:role]
+            when "user"
+              items << { role: "user", parts: [{ text: m[:content].to_s }] }
+            when "assistant"
+              items << { role: "model", parts: [{ text: m[:content].to_s }] }
+            when "assistant_tool_calls"
+              # Gemini doesn't need us to echo previous functionCall(s)
+              # Skip: model will remember its own functionCall
+            when "tool_result"
+              # Provide functionResponse so model can continue
+              name = m[:name] || "tool"
+              items << { role: "user", parts: [{ functionResponse: { name: name, response: { content: m[:content].to_s } } }] }
+            end
+          end
+          items
+        end
+
+        def extract_sse_line!(buffer)
+          if (i = buffer.index("\n"))
+            line = buffer.slice!(0..i)
+            line.chomp!
+            return line
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/drivers/openai/async_driver.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+require "async"
+require "async/http/internet"
+require "json"
+
+module VSM
+  module Drivers
+    module OpenAI
+      class AsyncDriver
+        def initialize(api_key:, model:, base_url: "https://api.openai.com/v1")
+          @api_key, @model, @base = api_key, model, base_url
+        end
+
+        MAX_TOOL_TURNS = 8
+
+        def run!(conversation:, tools:, policy: {}, &emit)
+          internet = Async::HTTP::Internet.new
+          begin
+              headers = {
+                "Authorization" => "Bearer #{@api_key}",
+                "Content-Type"  => "application/json",
+                "Accept"        => "text/event-stream"
+              }
+
+              messages = to_openai_messages(conversation, policy[:system_prompt])
+              tool_list = normalize_openai_tools(tools)
+
+              req_body = JSON.dump({
+                model: @model,
+                messages: messages,
+                tools: tool_list,
+                tool_choice: "auto",
+                stream: true
+              })
+              
+              # Debug logging
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "openai => messages: #{JSON.pretty_generate(messages)}"
+                $stderr.puts "openai => tools count: #{tool_list.size}"
+              end
+
+              response = internet.post("#{@base}/chat/completions", headers, req_body)
+
+              if response.status != 200
+                body = response.read
+                warn "openai HTTP #{response.status}: #{body}"
+                emit.call(:assistant_final, "")
+                return :done
+              end
+
+              buffer      = +""
+              text_buffer = +""
+              tc_partial  = Hash.new { |h,k| h[k] = { id: nil, name: nil, args_str: +"" } }
+
+              response.body.each do |chunk|
+                buffer << chunk
+                while (line = extract_sse_line!(buffer))
+                  next if line.empty? || line.start_with?(":")
+                  next unless line.start_with?("data:")
+                  data = line.sub("data:","").strip
+                  $stderr.puts("openai <= #{data}") if ENV["VSM_DEBUG_STREAM"] == "1"
+                  next if data == "[DONE]"
+
+                  obj = JSON.parse(data) rescue nil
+                  next unless obj
+                  choice = obj.dig("choices",0) || {}
+                  delta  = choice["delta"] || {}
+
+                  if (content = delta["content"])
+                    text_buffer << content
+                    emit.call(:assistant_delta, content)
+                  end
+
+                  if (tcs = delta["tool_calls"])
+                    tcs.each do |tc|
+                      idx  = tc["index"] || 0
+                      cell = tc_partial[idx]
+                      cell[:id]   ||= tc["id"]
+                      fn           = tc["function"] || {}
+                      cell[:name] ||= fn["name"] if fn["name"]
+                      cell[:args_str] << (fn["arguments"] || "")
+                    end
+                  end
+
+                  if (fr = choice["finish_reason"])
+                    case fr
+                    when "tool_calls"
+                      calls = tc_partial.keys.sort.map do |i|
+                        cell = tc_partial[i]
+                        {
+                          id:  cell[:id]   || "call_#{i}",
+                          name: cell[:name] || "unknown_tool",
+                          arguments: safe_json(cell[:args_str])
+                        }
+                      end
+                      tc_partial.clear
+                      emit.call(:tool_calls, calls)
+                    when "stop", "length", "content_filter"
+                      emit.call(:assistant_final, text_buffer.dup)
+                      text_buffer.clear
+                    end
+                  end
+                end
+              end
+          ensure
+            internet.close
+          end
+          :done
+        end
+
+        private
+        def normalize_openai_tools(tools)
+          Array(tools).map { |t| normalize_openai_tool(t) }
+        end
+
+        def normalize_openai_tool(t)
+          # Case 1: our Descriptor object
+          return t.to_openai_tool if t.respond_to?(:to_openai_tool)
+
+          # Case 2: provider-shaped already (OpenAI tools API)
+          if (t.is_a?(Hash) && (t[:type] || t["type"]))
+            return t
+          end
+
+          # Case 3: neutral hash {name:, description:, schema:}
+          if t.is_a?(Hash) && (t[:name] || t["name"])
+            return {
+              type: "function",
+              function: {
+                name:        t[:name]        || t["name"],
+                description: t[:description] || t["description"] || "",
+                parameters:  t[:schema]      || t["schema"]      || {}
+              }
+            }
+          end
+
+          raise TypeError, "unsupported tool descriptor: #{t.inspect}"
+        end
+
+
+        def to_openai_messages(neutral, system_prompt)
+          msgs = []
+          msgs << { role: "system", content: system_prompt } if system_prompt
+          neutral.each do |m|
+            case m[:role]
+            when "user"
+              msgs << { role: "user", content: m[:content].to_s }
+            when "assistant"
+              msgs << { role: "assistant", content: m[:content].to_s }
+            when "assistant_tool_calls"
+              msg = {
+                role: "assistant",
+                tool_calls: Array(m[:tool_calls]).map { |c|
+                  {
+                    id: c[:id],
+                    type: "function",
+                    function: {
+                      name: c[:name],
+                      arguments: JSON.dump(c[:arguments] || {})
+                    }
+                  }
+                }
+              }
+              msgs << msg
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "OpenAI: Converting assistant_tool_calls: #{msg[:tool_calls].map{|tc| "#{tc[:function][:name]}(#{tc[:id]})"}.join(', ')}"
+              end
+            when "tool_result"
+              msg = {
+                role: "tool",
+                tool_call_id: m[:tool_call_id],
+                content: m[:content].to_s
+              }
+              msgs << msg
+              if ENV["VSM_DEBUG_STREAM"] == "1"
+                $stderr.puts "OpenAI: Converting tool_result(#{m[:tool_call_id]}): #{m[:content].to_s.slice(0, 100)}"
+              end
+            end
+          end
+          msgs
+        end
+
+        def extract_sse_line!(buffer)
+          if (i = buffer.index("\n"))
+            line = buffer.slice!(0..i)
+            line.chomp!
+            return line
+          end
+          nil
+        end
+
+        def safe_json(s)
+          return {} if s.nil? || s.empty?
+          JSON.parse(s)
+        rescue JSON::ParserError
+          { "_raw" => s }
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/dsl.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "meta"
+module VSM
+  module DSL
+    class Builder
+      def initialize(name)
+        @name = name
+        @roles = {}
+        @children = {}
+        @after_build = []
+      end
+
+      def identity(klass: VSM::Identity, args: {})     = assign_role(:identity, klass, args)
+      def governance(klass: VSM::Governance, args: {}) = assign_role(:governance, klass, args)
+      def coordination(klass: VSM::Coordination, args: {}) = assign_role(:coordination, klass, args)
+      def intelligence(klass: VSM::Intelligence, args: {}) = assign_role(:intelligence, klass, args)
+      def operations(klass: VSM::Operations, args: {}, &blk)
+        @roles[:operations] = instantiate(klass, args)
+        if blk
+          builder = ChildrenBuilder.new(self)
+          builder.instance_eval(&blk)
+          @children.merge!(builder.result)
+        end
+      end
+
+      def monitoring(klass: VSM::Monitoring, args: {}) = assign_role(:monitoring, klass, args)
+
+      def build
+        # Inject governance into tool capsules if they accept it
+        @children.each_value do |child|
+          child.governance = @roles[:governance] if child.respond_to?(:governance=)
+        end
+        capsule = VSM::Capsule.new(name: @name, roles: @roles, children: @children)
+        @after_build.each { _1.call(capsule) }
+        capsule
+      end
+
+      class ChildrenBuilder
+        def initialize(parent)
+          @parent = parent
+          @children = {}
+        end
+        def capsule(name, klass:, args: {})
+          instance = klass.new(**args)
+          VSM::Meta::Support.record_constructor_args(instance, args)
+          @children[name.to_s] = instance
+        end
+        def meta_tools(prefix: "", only: nil, except: nil)
+          @parent.__send__(:after_build) do |capsule|
+            VSM::Meta.attach!(capsule, prefix: prefix, only: only, except: except)
+          end
+          result
+        end
+        def result = @children
+        def method_missing(*) = result
+        def respond_to_missing?(*) = true
+      end
+
+      private
+
+      def after_build(&block)
+        @after_build << block if block
+      end
+
+      def assign_role(key, klass, args)
+        @roles[key] = instantiate(klass, args)
+      end
+
+      def instantiate(klass, args)
+        instance = klass.new(**args)
+        VSM::Meta::Support.record_constructor_args(instance, args)
+      end
+    end
+
+    def self.define(name, &blk)
+      Builder.new(name).tap { |b| b.instance_eval(&blk) }.build
+    end
+  end
+end

data/lib/vsm/dsl_mcp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require_relative "dsl"
+require_relative "mcp/client"
+require_relative "mcp/remote_tool_capsule"
+
+module VSM
+  module DSL
+    class Builder
+      class ChildrenBuilder
+        # Reflect tools from a remote MCP server and add them as tool capsules.
+        # Options:
+        #   include: Array<String> whitelist of tool names
+        #   exclude: Array<String> blacklist of tool names
+        #   prefix:  String prefix for local names to avoid collisions
+        #   env:     Hash environment passed to the server process
+        #   cwd:     Working directory for spawning the process
+        #
+        # Example:
+        #   mcp_server :smith, cmd: "smith-server --stdio", include: %w[search read], prefix: "smith_"
+        def mcp_server(name, cmd:, env: {}, include: nil, exclude: nil, prefix: nil, cwd: nil)
+          client = VSM::MCP::Client.new(cmd: cmd, env: env, cwd: cwd, name: name.to_s).start
+          tools  = client.list_tools
+          tools.each do |t|
+            tool_name = t[:name]
+            next if include && !Array(include).include?(tool_name)
+            next if exclude &&  Array(exclude).include?(tool_name)
+            local_name = [prefix, tool_name].compact.join
+            capsule = VSM::MCP::RemoteToolCapsule.new(client: client, remote_name: tool_name, descriptor: t)
+            @children[local_name] = capsule
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vsm/executors/fiber_executor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module VSM
+  module Executors
+    module FiberExecutor
+      def self.call(tool, args)
+        tool.run(args) # runs in current Async task
+      end
+    end
+  end
+end

data/lib/vsm/executors/thread_executor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module VSM
+  module Executors
+    module ThreadExecutor
+      def self.call(tool, args)
+        q = Queue.new
+        Thread.new do
+          begin
+            q << [:ok, tool.run(args)]
+          rescue => e
+            q << [:err, e]
+          end
+        end
+        tag, val = q.pop
+        tag == :ok ? val : raise(val)
+      end
+    end
+  end
+end

data/lib/vsm/generator/new_project.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+require 'pathname'
+require_relative '../version'
+
+module VSM
+  module Generator
+    class NewProject
+      TemplateRoot = File.expand_path('templates', __dir__)
+
+      def self.run(name:, path: nil, git: false, bundle: false, provider: 'openai', model: nil, force: false)
+        new(name: name, path: path, git: git, bundle: bundle, provider: provider, model: model, force: force).run
+      end
+
+      def initialize(name:, path:, git:, bundle:, provider:, model:, force:)
+        @input_name = name
+        @target_dir = File.expand_path(path || name)
+        @git = git
+        @bundle = bundle
+        @provider = provider
+        @model = model
+        @force = force
+      end
+
+      def run
+        prepare_target_dir!
+
+        # Create directory tree
+        mkdirs(
+          'exe',
+          'bin',
+          "lib/#{lib_name}",
+          "lib/#{lib_name}/ports",
+          "lib/#{lib_name}/tools"
+        )
+
+        # Render files
+        write('README.md', render('README_md.erb'))
+        write('.gitignore', render('gitignore.erb'))
+        write('Gemfile', render('Gemfile.erb'))
+        write('Rakefile', render('Rakefile.erb'))
+        write("#{lib_name}.gemspec", render('gemspec.erb'))
+
+        write("exe/#{exe_name}", render('exe_name.erb'), mode: 0o755)
+        write('bin/console', render('bin_console.erb'), mode: 0o755)
+        write('bin/setup', render('bin_setup.erb'), mode: 0o755)
+
+        write("lib/#{lib_name}.rb", render('lib_name_rb.erb'))
+        write("lib/#{lib_name}/version.rb", render('lib_version_rb.erb'))
+        write("lib/#{lib_name}/organism.rb", render('lib_organism_rb.erb'))
+        write("lib/#{lib_name}/ports/chat_tty.rb", render('lib_ports_chat_tty_rb.erb'))
+        write("lib/#{lib_name}/tools/read_file.rb", render('lib_tools_read_file_rb.erb'))
+
+        post_steps
+
+        puts <<~DONE
+          
+          Created #{module_name} in #{@target_dir}
+          
+          Next steps:
+            cd #{relative_target}
+            bundle install
+            bundle exec exe/#{exe_name}
+          
+          Add tools in lib/#{lib_name}/tools and customize banner in lib/#{lib_name}/ports/chat_tty.rb.
+      DONE
+      end
+
+      private
+
+      def mkdirs(*dirs)
+        dirs.each { |d| FileUtils.mkdir_p(File.join(@target_dir, d)) }
+      end
+
+      def write(rel, content, mode: nil)
+        full = File.join(@target_dir, rel)
+        FileUtils.mkdir_p(File.dirname(full))
+        File.write(full, content)
+        File.chmod(mode, full) if mode
+      end
+
+      def render(template_name)
+        template_path = File.join(TemplateRoot, template_name)
+        erb = ERB.new(File.read(template_path), trim_mode: '-')
+        erb.result(binding)
+      end
+
+      def post_steps
+        Dir.chdir(@target_dir) do
+          if @git
+            system('git', 'init')
+            system('git', 'add', '-A')
+            system('git', 'commit', '-m', 'init')
+          end
+          if @bundle
+            system('bundle', 'install')
+          end
+        end
+      end
+
+      def prepare_target_dir!
+        if Dir.exist?(@target_dir)
+          if !@force && !(Dir.children(@target_dir) - %w[. ..]).empty?
+            raise "Target directory already exists and is not empty: #{@target_dir} (use --force to overwrite)"
+          end
+        else
+          FileUtils.mkdir_p(@target_dir)
+        end
+      end
+
+      # --- Template helpers (available via binding) ---
+
+      def module_name
+        @module_name ||= @input_name.split(/[-_]/).map { |p| p.gsub(/[^a-zA-Z0-9]/, '').capitalize }.join
+      end
+
+      def lib_name
+        @lib_name ||= @input_name.downcase.gsub('-', '_')
+      end
+
+      def exe_name
+        @exe_name ||= @input_name.downcase.gsub('_', '-')
+      end
+
+      def env_prefix
+        @env_prefix ||= @input_name.gsub('-', '_').upcase
+      end
+
+      def vsm_version_constraint
+        parts = Vsm::VERSION.split('.')
+        "~> #{parts[0]}.#{parts[1]}"
+      end
+
+      def provider
+        (@provider || 'openai').downcase
+      end
+
+      def default_model
+        return @model if @model && !@model.empty?
+        case provider
+        when 'anthropic' then 'claude-3-5-sonnet-latest'
+        when 'gemini'    then 'gemini-2.0-flash'
+        else 'gpt-4o-mini'
+        end
+      end
+
+      def relative_target
+        Pathname.new(@target_dir).relative_path_from(Pathname.new(Dir.pwd)).to_s rescue @target_dir
+      end
+    end
+  end
+end

data/lib/vsm/generator/templates/Gemfile.erb

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "vsm", "<%= vsm_version_constraint %>"
+
+group :development do
+  gem "rake"
+  gem "rspec"
+end
+