fosm-rails-coding-agent 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8aba38bcc58a867fae2d76824dec90a627c571acbbf0a29c6db2c6aa03b5b1d
-  data.tar.gz: bb7e8204e91f4843d85577f2db65ee59a38370e28140a1c2db4eca3a40f99351
+  metadata.gz: f6aeb8d53bfaadc57317556a9e91f4c95fb633a8e3f365ca6ec3517e09b82af7
+  data.tar.gz: 062c37b29a701991b14c0f56782612f8c56b37bc2b16a171e70d434eb7078d43
 SHA512:
-  metadata.gz: b30439f18922944bf005157e424b76c0449f494e82f638af2ee985b1c205f221953214d7dbc37ef07981515eb0ddeef92641890ea7cb81504c6d3c7196d15822
-  data.tar.gz: 051c9159ae15c10e1546f7bb027ad4371a32acaff2d5296b401896bde8fc4dabddbfb4c6bc006873f7bfec0d03a56124775f415a15a38960b89c3659399b82ad
+  metadata.gz: 6cb0787f6e6937434f169847d67d7b0e650cab59e50b28f81b61a54047ec2975f7503a8630a6f4dcd3b25f83ed2cad825459093181a42d4bdacbfbe742beb364
+  data.tar.gz: f97879752c8e85594dea933577b0e20abccb4862a956af02ad87032913480b750b6e71d8dca1e3031503033defc82b7ac0b760afba73ab7081b749cc1cc23e6a

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to fosm-rails-coding-agent will be documented in this file.
 
+## [0.0.4] - 2026-03-29
+
+### Changed
+
+- **fosm-coding-agent is now a real coding agent** powered by Gemlings ToolCallingAgent.
+  Previously returned canned responses. Now uses an LLM (Claude Sonnet by default)
+  to read/write files, run bash commands, and reason step by step.
+- ACP prompts are handled by Gemlings agent.run() with streaming step notifications.
+- Added BashTool for running shell commands.
+- Added gemlings >= 0.3 as a direct dependency.
+- Agent model configurable via FOSM_AGENT_MODEL env var (default: anthropic/claude-sonnet-4-20250514).
+
 ## [0.0.1] - 2026-03-29
 
 ### Added

data/lib/fosm_rails_coding_agent/acp_agent.rb

@@ -3,77 +3,198 @@
 require "agent_client_protocol"
 require "json"
 require "securerandom"
+require "open3"
+require "gemlings"
+require "gemlings/tools/file_read"
+require "gemlings/tools/file_write"
 
 module FosmRailsCodingAgent
-  # ACP agent that implements the Agent Client Protocol.
-  # Provides push-based FOSM lifecycle context to coding agents.
+  # ACP agent powered by Gemlings ToolCallingAgent.
   #
-  # When a session starts, the agent proactively pushes:
-  # - All FOSM lifecycle definitions in the project
-  # - Available events for key records
-  # - Recent transition activity
+  # Bridges the Agent Client Protocol (stdio JSON-RPC) to a real LLM-powered
+  # coding agent. Each prompt is handled by a Gemlings agent that can read/write
+  # files, call tools, and reason step by step — not canned responses.
   #
-  # This is the José Valim insight: don't wait for the agent to ask,
-  # PUSH context so the coding agent starts with full situational awareness.
+  # On session start, FOSM lifecycle context is pushed proactively.
   class AcpAgent
     include AgentClientProtocol::AgentInterface
     include AgentClientProtocol::Helpers
 
+    DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514"
+
     def on_connect(conn)
       @conn = conn
+      @sessions = {}  # session_id => Gemlings::ToolCallingAgent
     end
 
-    def initialize_agent(protocol_version:, **)
+    def initialize_agent(protocol_version:, **_)
       AgentClientProtocol::Schema::InitializeResponse.new(
         protocol_version: AgentClientProtocol::PROTOCOL_VERSION,
         agent_info: AgentClientProtocol::Schema::Implementation.new(
-          name: "fosm-rails-coding-agent",
+          name: "fosm-coding-agent",
           version: FosmRailsCodingAgent::VERSION
         ),
         capabilities: AgentClientProtocol::Schema::AgentCapabilities.new
       )
     end
 
-    def new_session(cwd:, **)
-      session_id = "fosm-agent-#{SecureRandom.uuid}"
+    def new_session(cwd:, **_)
+      session_id = "fosm-#{SecureRandom.hex(8)}"
+
+      # Build a Gemlings agent with coding tools + FOSM context
+      agent = build_agent(cwd)
+      @sessions[session_id] = agent
 
-      # Proactively push FOSM context if available
-      push_fosm_context(session_id) if FosmRailsCodingAgent.fosm_available?
+      # Push FOSM context proactively
+      push_fosm_context(session_id)
 
       AgentClientProtocol::Schema::NewSessionResponse.new(
         session_id: session_id
       )
     end
 
-    def prompt(prompt:, session_id:, **)
-      prompt.each do |block|
-        text = case block
-               when AgentClientProtocol::Schema::TextContent then block.text
-               when Hash then block["text"] || block.inspect
-               else block.inspect
-               end
+    def prompt(prompt:, session_id:, **_)
+      agent = @sessions[session_id]
+      unless agent
+        send_error_message(session_id, "Session not found. Create a new session first.")
+        return end_turn
+      end
+
+      # Extract text from ACP prompt content blocks
+      text = prompt.map { |block|
+        case block
+        when AgentClientProtocol::Schema::TextContent then block.text
+        when Hash then block["text"] || block.inspect
+        else block.inspect
+        end
+      }.join("\n")
+
+      # Run the Gemlings agent in streaming mode — forward steps as ACP notifications
+      run_agent(agent, text, session_id)
+
+      end_turn
+    end
+
+    def cancel(session_id:, **_)
+      agent = @sessions[session_id]
+      agent&.interrupt
+    end
+
+    def authenticate(method_id:, **_)
+      AgentClientProtocol::Schema::AuthenticateResponse.new
+    end
+
+    private
+
+    def end_turn
+      AgentClientProtocol::Schema::PromptResponse.new(
+        stop_reason: AgentClientProtocol::Schema::StopReason::END_TURN
+      )
+    end
+
+    # Build a Gemlings ToolCallingAgent with file tools and FOSM instructions.
+    def build_agent(cwd)
+      tools = [Gemlings::FileRead, Gemlings::FileWrite, BashTool]
+
+      model = ENV.fetch("FOSM_AGENT_MODEL", DEFAULT_MODEL)
+      instructions = build_instructions(cwd)
+
+      Gemlings::ToolCallingAgent.new(
+        model: model,
+        tools: tools,
+        max_steps: 20,
+        instructions: instructions,
+        name: "fosm-coding-agent"
+      )
+    end
+
+    def build_instructions(cwd)
+      instructions = <<~INST
+        You are a coding agent working in a Rails application at: #{cwd}
+
+        You can read files, write files, and run bash commands to help the developer.
+        When asked about the app, explore the codebase. When asked to make changes, do so.
+        Always explain what you're doing before making changes.
+      INST
+
+      # Append FOSM context if available
+      fosm_context = build_fosm_context
+      instructions += "\n\n#{fosm_context}" unless fosm_context.empty?
+
+      instructions
+    end
+
+    # Run the agent and stream results back as ACP notifications.
+    def run_agent(agent, task, session_id)
+      # Use step-by-step execution so we can stream each step
+      agent.reset!
+      step = agent.step(task)
+      stream_step(step, session_id)
+
+      until agent.done?
+        step = agent.step
+        stream_step(step, session_id)
+      end
+
+      # Send the final answer
+      if agent.final_answer_value
+        send_agent_message(session_id, agent.final_answer_value.to_s)
+      end
+    rescue Gemlings::MaxStepsError
+      send_agent_message(session_id, "Reached maximum steps. Please provide more guidance.")
+    rescue Gemlings::InterruptError
+      send_agent_message(session_id, "Cancelled.")
+    rescue => e
+      send_error_message(session_id, "Agent error: #{e.message}")
+    end
 
-        response = handle_prompt_text(text, session_id)
+    # Convert a Gemlings step into ACP session/update notifications.
+    def stream_step(step, session_id)
+      return unless step
 
+      # Stream thought
+      if step.respond_to?(:thought) && step.thought
         @conn.session_update(
           session_id: session_id,
-          update: update_agent_message_text(response)
+          update: update_agent_thought_text(step.thought)
         )
       end
 
-      AgentClientProtocol::Schema::PromptResponse.new(
-        stop_reason: AgentClientProtocol::Schema::StopReason::END_TURN
-      )
+      # Stream tool calls
+      if step.respond_to?(:tool_calls) && step.tool_calls&.any?
+        step.tool_calls.each do |tc|
+          @conn.session_update(
+            session_id: session_id,
+            update: start_tool_call(
+              tc.id || SecureRandom.hex(8),
+              "#{tc.function.name}(#{tc.function.arguments.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})",
+              status: AgentClientProtocol::Schema::ToolCallStatus::COMPLETED
+            )
+          )
+        end
+      end
+
+      # Stream observation/output
+      if step.respond_to?(:observation) && step.observation
+        send_agent_message(session_id, step.observation)
+      end
     end
 
-    def authenticate(method_id:, **)
-      AgentClientProtocol::Schema::AuthenticateResponse.new
+    def send_agent_message(session_id, text)
+      @conn.session_update(
+        session_id: session_id,
+        update: update_agent_message_text(text)
+      )
     end
 
-    private
+    def send_error_message(session_id, text)
+      @conn.session_update(
+        session_id: session_id,
+        update: update_agent_message_text("Error: #{text}")
+      )
+    end
 
-    # Push FOSM lifecycle context at session start so the coding agent
-    # has full awareness of the state machines in the project.
+    # Push FOSM lifecycle context at session start.
     def push_fosm_context(session_id)
       context = build_fosm_context
       return if context.empty?
@@ -82,8 +203,7 @@ module FosmRailsCodingAgent
         session_id: session_id,
         update: update_agent_message_text(
           "## FOSM Lifecycle Context\n\n" \
-          "This Rails application uses FOSM (Finite Observable State Machine) " \
-          "lifecycles. Here are the registered state machines:\n\n#{context}"
+          "This Rails application uses FOSM lifecycles:\n\n#{context}"
         )
       )
     end
@@ -109,24 +229,27 @@ module FosmRailsCodingAgent
           "  #{e.name}: #{e.from_states.join(", ")} → #{e.to_state}"
         end
 
-        "### #{klass.name}\n" \
-        "States: #{states.join(", ")}\n" \
-        "Events:\n#{events.join("\n")}\n"
+        "### #{klass.name}\nStates: #{states.join(", ")}\nEvents:\n#{events.join("\n")}\n"
       end.join("\n")
     end
+  end
 
-    def handle_prompt_text(text, session_id)
-      case text.downcase.strip
-      when /lifecycles?/
-        build_fosm_context.presence || "No FOSM lifecycles found in this project."
-      when /help/
-        "FosmRailsCodingAgent ACP agent provides FOSM-aware runtime intelligence.\n" \
-        "FOSM tools are available via the MCP server at /fosm-agent/mcp.\n" \
-        "Ask about lifecycles, states, events, or transitions."
-      else
-        "FosmRailsCodingAgent is listening. Use the MCP tools at /fosm-agent/mcp for " \
-        "SQL queries, logs, code evaluation, and FOSM introspection."
-      end
+  # Simple bash tool for the Gemlings agent.
+  class BashTool < Gemlings::Tool
+    tool_name "bash"
+    description "Execute a bash command and return stdout/stderr. Use for running tests, git, rake, etc."
+    input :command, type: :string, description: "The bash command to execute"
+    output_type :string
+
+    def call(command:)
+      stdout, stderr, status = Open3.capture3(command)
+      output = ""
+      output += stdout unless stdout.empty?
+      output += "\nSTDERR: #{stderr}" unless stderr.empty?
+      output += "\nExit: #{status.exitstatus}" unless status.success?
+      output.empty? ? "(no output)" : output.strip
+    rescue => e
+      "Error: #{e.message}"
     end
   end
 end

data/lib/fosm_rails_coding_agent/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FosmRailsCodingAgent
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/generators/fosm/mcp_config/mcp_config_generator.rb

@@ -7,7 +7,7 @@ module Fosm
     # Usage:
     #   rails generate fosm:mcp_config
     #   rails generate fosm:mcp_config --port=4000
-    class McpConfigGenerator < Rails::Generators::Base
+    class McpConfigGenerator < ::Rails::Generators::Base
       desc "Creates .mcp.json for Claude Code / Codex / Copilot MCP integration"
 
       class_option :port, type: :numeric, default: 3000,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fosm-rails-coding-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Abhishek Parolkar
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: gemlings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: |
   Embeds a FOSM-aware MCP server and ACP agent into your Rails development
   environment, giving coding agents (Claude Code, Codex, Copilot) runtime intelligence: