rubyn-code 0.5.1 → 0.7.0

data/lib/rubyn_code/tools/spawn_agent.rb

@@ -9,8 +9,9 @@ module RubynCode
       TOOL_NAME = 'spawn_agent'
       DESCRIPTION = 'Spawn an isolated sub-agent to handle a task. The sub-agent gets its own ' \
                     "fresh context, works independently, and returns only a summary. Use 'explore' " \
-                    "type for research/reading, 'worker' type for writing code/files. The sub-agent " \
-                    'shares the filesystem but not your conversation.'
+                    "type for research/reading, 'worker' type for writing code/files, or the name " \
+                    'of any custom agent defined in .rubyn-code/agents/. The sub-agent shares the ' \
+                    'filesystem but not your conversation.'
       PARAMETERS = {
         prompt: {
           type: :string,
@@ -19,76 +20,73 @@ module RubynCode
         },
         agent_type: {
           type: :string,
-          description: "Type of agent: 'explore' (read-only) or 'worker' (full write access). Default: explore",
-          required: false,
-          enum: %w[explore worker]
+          description: "Agent type: 'explore' (read-only), 'worker' (full write access), or a " \
+                       'custom agent name from .rubyn-code/agents/. Default: explore',
+          required: false
         }
       }.freeze
       RISK_LEVEL = :execute
 
+      READ_TOOLS = %w[read_file glob grep bash load_skill memory_search].freeze
+      BLOCKED_TOOLS = %w[spawn_agent send_message read_inbox compact memory_write].freeze
+
       # These get injected by the executor or the REPL
       attr_writer :llm_client, :on_status
 
       def execute(prompt:, agent_type: 'explore')
-        type = agent_type.to_sym
+        agent = resolve_agent(agent_type)
         callback = @on_status || method(:default_status)
         @tool_count = 0
 
-        callback.call(:started, "Spawning #{type} agent...")
+        callback.call(:started, "Spawning #{agent.name} agent...")
 
-        tools = tools_for_type(type)
-        result, hit_limit = run_sub_agent(
-          prompt: prompt, tools: tools, type: type, callback: callback
-        )
+        tools = tools_for(agent)
+        result, hit_limit = run_sub_agent(prompt: prompt, tools: tools, agent: agent, callback: callback)
 
         callback.call(:done, "Agent finished (#{@tool_count} tool calls).")
 
         summary = RubynCode::SubAgents::Summarizer.call(result, max_length: 3000)
-        format_agent_result(type, summary, hit_limit)
+        format_agent_result(agent.name, summary, hit_limit)
       end
 
       private
 
-      def format_agent_result(type, summary, hit_limit)
+      # Resolve the requested type via the catalog, falling back to explore
+      # for an unknown name so a typo degrades gracefully instead of erroring.
+      def resolve_agent(agent_type)
+        catalog = RubynCode::SubAgents::Catalog.new(project_root: project_root)
+        catalog.get(agent_type) || catalog.get('explore')
+      end
+
+      def format_agent_result(name, summary, hit_limit)
         if hit_limit
-          "## Sub-Agent Result (#{type}) — INCOMPLETE (reached #{@tool_count} tool calls)\n\n" \
+          "## Sub-Agent Result (#{name}) — INCOMPLETE (reached #{@tool_count} tool calls)\n\n" \
             'The sub-agent ran out of turns before finishing. Here is what it accomplished so far:' \
             "\n\n#{summary}"
         else
-          "## Sub-Agent Result (#{type})\n\n#{summary}"
-        end
-      end
-
-      def max_iterations_for(type)
-        if type == :explore
-          Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS
-        else
-          Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+          "## Sub-Agent Result (#{name})\n\n#{summary}"
         end
       end
 
       # Returns [result_text, hit_limit] tuple
-      def run_sub_agent(prompt:, tools:, type:, callback:)
+      def run_sub_agent(prompt:, tools:, agent:, callback:)
         conversation = RubynCode::Agent::Conversation.new
         conversation.add_user_message(prompt)
 
-        max_iterations = max_iterations_for(type)
         iteration = 0
         last_text = nil
 
         loop do
-          return finish_at_limit(conversation, type, last_text) if iteration >= max_iterations
+          return finish_at_limit(conversation, agent, last_text) if iteration >= agent.max_iterations
 
-          last_text, done = process_iteration(
-            conversation, tools, type, callback, last_text
-          )
+          last_text, done = process_iteration(conversation, tools, agent, callback, last_text)
           return [last_text || '', false] if done
 
           iteration += 1
         end
       end
 
-      def finish_at_limit(conversation, type, last_text)
+      def finish_at_limit(conversation, agent, last_text)
         conversation.add_user_message(
           'You have reached your turn limit. Summarize everything you found or ' \
           'accomplished so far. Be thorough — this is your last chance to report back.'
@@ -96,17 +94,17 @@ module RubynCode
         response = @llm_client.chat(
           messages: conversation.to_api_format,
           tools: [],
-          system: sub_agent_system_prompt(type)
+          system: agent.system_prompt
         )
         summary = extract_text(response)
         [summary.empty? ? (last_text || '') : summary, true]
       end
 
-      def process_iteration(conversation, tools, type, callback, last_text)
+      def process_iteration(conversation, tools, agent, callback, last_text)
         response = @llm_client.chat(
           messages: conversation.to_api_format,
           tools: tools,
-          system: sub_agent_system_prompt(type)
+          system: agent.system_prompt
         )
 
         content = response_content(response)
@@ -117,22 +115,22 @@ module RubynCode
         conversation.add_assistant_message(content)
         return [last_text, true] if tool_calls.empty?
 
-        execute_sub_agent_tools(tool_calls, conversation, type, callback)
+        execute_sub_agent_tools(tool_calls, conversation, agent, callback)
         [last_text, false]
       end
 
-      def execute_sub_agent_tools(tool_calls, conversation, type, callback)
+      def execute_sub_agent_tools(tool_calls, conversation, agent, callback)
         tool_calls.each do |tc|
           name, input, id = extract_tool_call(tc)
           @tool_count += 1
           callback.call(:tool, name.to_s)
 
-          run_single_tool(name, input, id, conversation, type)
+          run_single_tool(name, input, id, conversation, agent)
         end
       end
 
-      def run_single_tool(name, input, id, conversation, type)
-        if %w[spawn_agent].include?(name)
+      def run_single_tool(name, input, id, conversation, agent)
+        if name == 'spawn_agent'
           conversation.add_tool_result(
             id, name, 'Error: Sub-agents cannot spawn other agents.', is_error: true
           )
@@ -140,9 +138,9 @@ module RubynCode
         end
 
         tool_class = RubynCode::Tools::Registry.get(name)
-        if type == :explore && tool_class.risk_level != :read
+        if agent.read_only? && tool_class.risk_level != :read
           conversation.add_tool_result(
-            id, name, 'Error: Explore agents can only use read-only tools.', is_error: true
+            id, name, "Error: #{agent.name} agents can only use read-only tools.", is_error: true
           )
           return
         end
@@ -154,31 +152,18 @@ module RubynCode
         conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
       end
 
-      def tools_for_type(type)
+      # The tool allowlist: explicit list from a custom agent, else the
+      # access-based default (read-only set or everything-minus-blocked).
+      def tools_for(agent)
         all_tools = RubynCode::Tools::Registry.tool_definitions
-        blocked = %w[spawn_agent send_message read_inbox compact memory_write]
-
-        if type == :explore
-          read_tools = %w[read_file glob grep bash load_skill memory_search]
-          all_tools.select { |t| read_tools.include?(t[:name]) }
-        else
-          all_tools.reject { |t| blocked.include?(t[:name]) }
-        end
-      end
 
-      def sub_agent_system_prompt(type)
-        base = 'You are a Rubyn sub-agent. Complete your task efficiently and ' \
-               'return a clear summary of what you found or did.'
-
-        case type
-        when :explore
-          "#{base}\nYou have read-only access. Search, read files, and analyze. " \
-          'Do NOT attempt to write or modify anything.'
-        when :worker
-          "#{base}\nYou have full read/write access. Make the changes needed, " \
-          'run tests if appropriate, and report what you did.'
+        if agent.tool_names && !agent.tool_names.empty?
+          allowed = agent.tool_names - BLOCKED_TOOLS
+          all_tools.select { |t| allowed.include?(t[:name]) }
+        elsif agent.read_only?
+          all_tools.select { |t| READ_TOOLS.include?(t[:name]) }
         else
-          base
+          all_tools.reject { |t| BLOCKED_TOOLS.include?(t[:name]) }
         end
       end
 

data/lib/rubyn_code/tools/spawn_teammate.rb

@@ -25,13 +25,18 @@ module RubynCode
           type: :string,
           description: 'Initial task or instruction for the teammate',
           required: true
+        },
+        parent_agent_id: {
+          type: :string,
+          description: 'ID of the parent agent spawning this teammate (for lineage tracking)',
+          required: false
         }
       }.freeze
       RISK_LEVEL = :execute
 
       attr_writer :llm_client, :on_status, :db
 
-      def execute(name:, role:, prompt:)
+      def execute(name:, role:, prompt:, parent_agent_id: nil)
         callback = @on_status || method(:default_status)
 
         raise Error, 'LLM client not available' unless @llm_client
@@ -40,7 +45,7 @@ module RubynCode
         mailbox = Teams::Mailbox.new(@db)
         manager = Teams::Manager.new(@db, mailbox: mailbox)
 
-        teammate = manager.spawn(name: name, role: role)
+        teammate = manager.spawn(name: name, role: role, parent_agent_id: parent_agent_id)
         callback.call(:started, "Spawning teammate '#{name}' as #{role}...")
 
         Thread.new do

data/lib/rubyn_code/tools/web_fetch.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require_relative 'base'
 require_relative 'registry'
 
@@ -76,6 +75,7 @@ module RubynCode
       end
 
       def build_connection
+        require 'faraday'
         Faraday.new do |f|
           f.options.timeout = 30
           f.options.open_timeout = 10

data/lib/rubyn_code/tools/web_search.rb

@@ -3,7 +3,6 @@
 require 'open3'
 require 'cgi'
 require 'json'
-require 'faraday'
 require_relative 'base'
 require_relative 'registry'
 
@@ -112,6 +111,7 @@ module RubynCode
       end
 
       def brave_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://api.search.brave.com/res/v1/web/search') do |req|
           req.params['q'] = query
           req.params['count'] = num_results
@@ -135,6 +135,7 @@ module RubynCode
       end
 
       def tavily_request(query, num_results)
+        require 'faraday'
         Faraday.post('https://api.tavily.com/search') do |req|
           req.headers['Content-Type'] = 'application/json'
           req.body = JSON.generate(
@@ -156,6 +157,7 @@ module RubynCode
       end
 
       def serpapi_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://serpapi.com/search.json') do |req|
           req.params['q'] = query
           req.params['num'] = num_results
@@ -175,6 +177,7 @@ module RubynCode
       end
 
       def google_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://www.googleapis.com/customsearch/v1') do |req|
           req.params['q'] = query
           req.params['num'] = [num_results, 10].min

data/lib/rubyn_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubynCode
-  VERSION = '0.5.1'
+  VERSION = '0.7.0'
 end

data/lib/rubyn_code.rb

@@ -16,11 +16,16 @@ module RubynCode
   # rather than a successful tool call returning a string like "denied".
   class UserDeniedError < Error; end
 
-  # Infrastructure
-  autoload :Config, 'rubyn_code/config/settings'
+  # Chisel — opt-in "write the minimum that works" enforcement (off by default)
+  autoload :Chisel, 'rubyn_code/chisel'
 
+  # Infrastructure
   module Config
+    autoload :Settings, 'rubyn_code/config/settings'
+    autoload :Defaults, 'rubyn_code/config/defaults'
+    autoload :ProjectConfig, 'rubyn_code/config/project_config'
     autoload :ProjectProfile, 'rubyn_code/config/project_profile'
+    autoload :Validator, 'rubyn_code/config/validator'
   end
 
   # Database
@@ -49,6 +54,7 @@ module RubynCode
       autoload :Base, 'rubyn_code/llm/adapters/base'
       autoload :JsonParsing, 'rubyn_code/llm/adapters/json_parsing'
       autoload :PromptCaching, 'rubyn_code/llm/adapters/prompt_caching'
+      autoload :TokenCaching, 'rubyn_code/llm/adapters/token_caching'
       autoload :Anthropic, 'rubyn_code/llm/adapters/anthropic'
       autoload :AnthropicCompatible, 'rubyn_code/llm/adapters/anthropic_compatible'
       autoload :AnthropicStreaming, 'rubyn_code/llm/adapters/anthropic_streaming'
@@ -153,6 +159,14 @@ module RubynCode
   module SubAgents
     autoload :Runner, 'rubyn_code/sub_agents/runner'
     autoload :Summarizer, 'rubyn_code/sub_agents/summarizer'
+    autoload :AgentType, 'rubyn_code/sub_agents/agent_type'
+    autoload :Catalog, 'rubyn_code/sub_agents/catalog'
+  end
+
+  # Checkpoints (/rewind)
+  module Checkpoint
+    autoload :Manager, 'rubyn_code/checkpoint/manager'
+    autoload :Hook, 'rubyn_code/checkpoint/hook'
   end
 
   # Layer 7: Tasks
@@ -181,6 +195,7 @@ module RubynCode
     autoload :Manager, 'rubyn_code/teams/manager'
     autoload :Mailbox, 'rubyn_code/teams/mailbox'
     autoload :Teammate, 'rubyn_code/teams/teammate'
+    autoload :AgentRegistry, 'rubyn_code/teams/agent_registry'
   end
 
   # Layer 10: Protocols
@@ -222,6 +237,17 @@ module RubynCode
     autoload :Runner, 'rubyn_code/hooks/runner'
     autoload :BuiltIn, 'rubyn_code/hooks/built_in'
     autoload :UserHooks, 'rubyn_code/hooks/user_hooks'
+    autoload :GoalHook, 'rubyn_code/hooks/goal_hook'
+    autoload :EventMap, 'rubyn_code/hooks/event_map'
+    autoload :Response, 'rubyn_code/hooks/response'
+    autoload :SettingsJsonLoader, 'rubyn_code/hooks/settings_json_loader'
+    autoload :SubprocessExecutor, 'rubyn_code/hooks/subprocess_executor'
+    autoload :ExternalDispatcher, 'rubyn_code/hooks/external_dispatcher'
+  end
+
+  # Session goals (/goal)
+  module Goal
+    autoload :Evaluator, 'rubyn_code/goal/evaluator'
   end
 
   # Layer 15: MCP
@@ -230,6 +256,7 @@ module RubynCode
     autoload :StdioTransport, 'rubyn_code/mcp/stdio_transport'
     autoload :SSETransport, 'rubyn_code/mcp/sse_transport'
     autoload :ToolBridge, 'rubyn_code/mcp/tool_bridge'
+    autoload :ServerExtrasBridge, 'rubyn_code/mcp/server_extras_bridge'
     autoload :Config, 'rubyn_code/mcp/config'
   end
 
@@ -240,6 +267,7 @@ module RubynCode
     autoload :InstinctMethods, 'rubyn_code/learning/instinct'
     autoload :Injector, 'rubyn_code/learning/injector'
     autoload :Shortcut, 'rubyn_code/learning/shortcut'
+    autoload :Porter, 'rubyn_code/learning/porter'
   end
 
   # IDE (VS Code extension server)
@@ -271,6 +299,8 @@ module RubynCode
     autoload :Setup, 'rubyn_code/cli/setup'
     autoload :FirstRun, 'rubyn_code/cli/first_run'
     autoload :DaemonRunner, 'rubyn_code/cli/daemon_runner'
+    autoload :LoopRunner, 'rubyn_code/cli/loop_runner'
+    autoload :MentionExpander, 'rubyn_code/cli/mention_expander'
     autoload :VersionCheck, 'rubyn_code/cli/version_check'
 
     # Slash Command System
@@ -304,6 +334,19 @@ module RubynCode
       autoload :RemoveSkills, 'rubyn_code/cli/commands/remove_skills'
       autoload :Skills, 'rubyn_code/cli/commands/skills'
       autoload :Megaplan, 'rubyn_code/cli/commands/megaplan'
+      autoload :Goal, 'rubyn_code/cli/commands/goal'
+      autoload :Loop, 'rubyn_code/cli/commands/loop'
+      autoload :Agents, 'rubyn_code/cli/commands/agents'
+      autoload :CommandTemplate, 'rubyn_code/cli/commands/command_template'
+      autoload :CustomCommand, 'rubyn_code/cli/commands/custom_command'
+      autoload :CustomLoader, 'rubyn_code/cli/commands/custom_loader'
+      autoload :Learning, 'rubyn_code/cli/commands/learning'
+      autoload :Rewind, 'rubyn_code/cli/commands/rewind'
+      autoload :Chisel, 'rubyn_code/cli/commands/chisel'
+      autoload :ChiselReview, 'rubyn_code/cli/commands/chisel_review'
+      autoload :ChiselAudit, 'rubyn_code/cli/commands/chisel_audit'
+      autoload :ChiselDebt, 'rubyn_code/cli/commands/chisel_debt'
+      autoload :ChiselGain, 'rubyn_code/cli/commands/chisel_gain'
     end
   end