rubyn-code 0.5.1 → 0.7.0

data/lib/rubyn_code/hooks/settings_json_loader.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubynCode
+  module Hooks
+    # Loads external hook commands from a Claude Code-compatible settings.json.
+    #
+    # Schema (matches Claude Code's hook config):
+    #
+    #   {
+    #     "hooks": {
+    #       "PreToolUse": [
+    #         {
+    #           "matcher": "bash|write_file",        // regex or "*"
+    #           "hooks": [
+    #             { "type": "command",
+    #               "command": "/usr/local/bin/policy-check",
+    #               "timeout": 60,
+    #               "env": { "FOO": "bar" }            // optional
+    #             }
+    #           ]
+    #         }
+    #       ],
+    #       "PostToolUse":      [ ... ],
+    #       "UserPromptSubmit": [ ... ],
+    #       "SessionStart":     [ ... ],
+    #       "SessionEnd":       [ ... ],
+    #       "Stop":             [ ... ],
+    #       "SubagentStop":     [ ... ],
+    #       "PreCompact":       [ ... ],
+    #       "Notification":     [ ... ]
+    #     }
+    #   }
+    #
+    # "matcher" may be:
+    #   - a regex string matched against the tool name (PreToolUse/PostToolUse)
+    #     or the session id (other events accept any value);
+    #   - "*" to match everything;
+    #   - omitted/null to match everything.
+    #
+    # The loader does not validate that commands exist on disk — that's the
+    # Executor's job (it will fail at fire time with a clear error).
+    class SettingsJsonLoader
+      class LoadError < RubynCode::Error
+      end
+
+      # @return [Array<String>] paths the loader will try, in order
+      attr_reader :search_paths
+
+      # @param project_root [String] used to locate .rubyn-code/settings.json
+      # @param home_dir [String, nil] override for ~/.rubyn-code; defaults to Defaults::HOME_DIR
+      def initialize(project_root:, home_dir: nil)
+        @home_dir = home_dir || Config::Defaults::HOME_DIR
+        @project_root = project_root
+        @search_paths = [
+          File.join(@project_root, '.rubyn-code', 'settings.json'),
+          File.join(@home_dir, 'settings.json')
+        ].freeze
+      end
+
+      # Loads and merges settings.json from project + global.
+      #
+      # Project wins for the same matcher/event combination: if both files
+      # define a hook for the same event, the project's hook runs first and
+      # the global hook runs after, mirroring Claude Code's behaviour.
+      #
+      # @return [Hash<String, Array<Hash>>] { event_name => [matcher_group, ...] }
+      #   where each matcher_group is { "matcher" => String, "hooks" => [command_hash, ...] }
+      def load
+        merged = {}
+        @search_paths.each do |path|
+          next unless File.exist?(path)
+
+          data = parse_file(path)
+          merge_into!(merged, data['hooks'] || {})
+        end
+        merged
+      end
+
+      private
+
+      def parse_file(path)
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError => e
+        raise LoadError, "Failed to parse hook settings at #{path}: #{e.message}"
+      end
+
+      def merge_into!(merged, hooks_section)
+        hooks_section.each do |event_name, matcher_groups|
+          next unless matcher_groups.is_a?(Array)
+
+          merged[event_name] ||= []
+          matcher_groups.each do |group|
+            next unless group.is_a?(Hash)
+
+            commands = Array(group['hooks']).select { |h| h.is_a?(Hash) && h['type'] == 'command' }
+            next if commands.empty?
+
+            merged[event_name] << {
+              'matcher' => group['matcher'] || '*',
+              'hooks' => commands
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/hooks/subprocess_executor.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'timeout'
+
+module RubynCode
+  module Hooks
+    # Spawns external hook commands and exchanges JSON with them.
+    #
+    # Protocol (matches Claude Code):
+    #   1. Spawn the command with { env, chdir: project_root }.
+    #   2. Write one JSON line to stdin:
+    #        { "hookEventName": "PreToolUse",
+    #          "sessionId": "...",
+    #          "toolName": "bash",          // when applicable
+    #          "toolInput": { ... },        // when applicable
+    #          "prompt": "user text..." }   // when applicable
+    #   3. Close stdin.
+    #   4. Read stdout until EOF or timeout. Parse as JSON.
+    #      - One JSON object spanning the whole output, OR
+    #      - Newline-delimited JSON (first parseable line wins).
+    #   5. Stderr is captured and logged but not parsed.
+    #
+    # The executor is stateless — each call spawns a fresh process. This is
+    # intentional: hooks must not keep state between invocations, and process
+    # startup cost (~30ms on macOS) is negligible compared to typical tool
+    # execution time.
+    class SubprocessExecutor
+      DEFAULT_TIMEOUT = 60 # seconds
+
+      class ExecutionError < RubynCode::Error
+      end
+
+      class TimeoutError < ExecutionError
+      end
+
+      # @param project_root [String] working directory for spawned processes
+      # @param default_timeout [Integer] fallback timeout when a hook entry
+      #   does not specify its own
+      def initialize(project_root:, default_timeout: DEFAULT_TIMEOUT)
+        @project_root = project_root
+        @default_timeout = default_timeout
+      end
+
+      # Runs a single hook command with the given event payload.
+      #
+      # @param command [String] executable path
+      # @param args [Array<String>] arguments (rarely used; settings.json
+      #   typically embeds everything in the command string)
+      # @param env [Hash<String, String>] additional environment variables
+      # @param payload [Hash] the JSON payload (must include :hookEventName)
+      # @param timeout [Integer, nil] per-call timeout override
+      # @return [Hash] the parsed JSON response from stdout (empty hash if no output)
+      # @raise [ExecutionError] on spawn failure
+      # @raise [TimeoutError] if the command does not finish in time
+      def run(command:, payload:, args: [], env: {}, timeout: nil)
+        timeout ||= @default_timeout
+        env = default_env.merge(env)
+
+        stdout, _stderr, = invoke(command, args, env, payload, timeout)
+        parse_response(stdout)
+      rescue Timeout::Error => e
+        raise TimeoutError, "Hook command '#{command}' timed out after #{timeout}s: #{e.message}"
+      end
+
+      private
+
+      def default_env
+        # Open3 replaces the entire env when env: is given, so inherit the
+        # parent's environment first and add our hook-specific markers.
+        ENV.to_h.merge(
+          'RUBYN_HOOK_EVENT' => '1',
+          'CLAUDE_PROJECT_DIR' => @project_root
+        )
+      end
+
+      def invoke(command, args, env, payload, timeout)
+        Timeout.timeout(timeout) do
+          Open3.capture3(env, command, *args, chdir: @project_root, stdin_data: JSON.generate(payload))
+        end
+      rescue Errno::ENOENT => e
+        raise ExecutionError, "Hook command not found: #{command} (#{e.message})"
+      rescue SystemCallError => e
+        raise ExecutionError, "Failed to spawn hook command '#{command}': #{e.message}"
+      end
+
+      def parse_response(stdout)
+        return {} if stdout.nil? || stdout.strip.empty?
+
+        # Try whole-output JSON first (Claude Code's preferred shape).
+        begin
+          parsed = JSON.parse(stdout)
+          return parsed.is_a?(Hash) ? parsed : { 'output' => parsed }
+        rescue JSON::ParserError
+          # Fall through to line-delimited scanning.
+        end
+
+        stdout.each_line do |line|
+          stripped = line.strip
+          next if stripped.empty?
+
+          begin
+            parsed = JSON.parse(stripped)
+            return parsed.is_a?(Hash) ? parsed : { 'output' => parsed }
+          rescue JSON::ParserError
+            next
+          end
+        end
+
+        # Non-JSON output: treat as raw output for debugging hooks.
+        { 'output' => stdout }
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_interview_answer_handler.rb

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 module RubynCode
   module IDE
@@ -22,7 +22,7 @@ module RubynCode
           session = @server.lookup_interview_session(session_id)
           unless session
             raise Protocol::JsonRpcError.new(SESSION_NOT_FOUND_CODE,
-                                              "Unknown interview session: #{session_id}")
+                                             "Unknown interview session: #{session_id}")
           end
 
           outcome = session.answer(question_id, answer)
@@ -34,9 +34,9 @@ module RubynCode
                Megaplan::PlanProposer::InvalidProposalError => e
           warn "[PlanInterviewAnswerHandler] interview failed: #{e.message}"
           @server.notify('plan/interview/error', {
-            'sessionId' => params['sessionId'],
-            'message' => e.message
-          })
+                           'sessionId' => params['sessionId'],
+                           'message' => e.message
+                         })
           @server.drop_interview_session(params['sessionId'].to_s)
           raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
         end
@@ -46,16 +46,16 @@ module RubynCode
         def emit_outcome(session, outcome)
           if outcome.is_a?(Megaplan::InterviewSession::Question)
             @server.notify('plan/interview/question', {
-              'sessionId' => session.session_id,
-              'questionId' => outcome.id,
-              'text' => outcome.text,
-              'options' => outcome.options
-            })
+                             'sessionId' => session.session_id,
+                             'questionId' => outcome.id,
+                             'text' => outcome.text,
+                             'options' => outcome.options
+                           })
           else
             @server.notify('plan/interview/done', {
-              'sessionId' => session.session_id,
-              'plan' => outcome
-            })
+                             'sessionId' => session.session_id,
+                             'plan' => outcome
+                           })
             @server.drop_interview_session(session.session_id)
           end
         end

data/lib/rubyn_code/ide/handlers/plan_interview_cancel_handler.rb

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 module RubynCode
   module IDE

data/lib/rubyn_code/ide/handlers/plan_interview_start_handler.rb

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 module RubynCode
   module IDE
@@ -12,7 +12,7 @@ module RubynCode
 
         def initialize(server, factory: nil)
           @server = server
-          @factory = factory || ->(workspace_path:) {
+          @factory = factory || lambda { |workspace_path:|
             Megaplan::InterviewSession.new(workspace_path: workspace_path)
           }
         end
@@ -34,16 +34,16 @@ module RubynCode
         def emit_outcome(session, outcome)
           if outcome.is_a?(Megaplan::InterviewSession::Question)
             @server.notify('plan/interview/question', {
-              'sessionId' => session.session_id,
-              'questionId' => outcome.id,
-              'text' => outcome.text,
-              'options' => outcome.options
-            })
+                             'sessionId' => session.session_id,
+                             'questionId' => outcome.id,
+                             'text' => outcome.text,
+                             'options' => outcome.options
+                           })
           else
             @server.notify('plan/interview/done', {
-              'sessionId' => session.session_id,
-              'plan' => outcome
-            })
+                             'sessionId' => session.session_id,
+                             'plan' => outcome
+                           })
             @server.drop_interview_session(session.session_id)
           end
         end

data/lib/rubyn_code/ide/handlers/plan_propose_handler.rb

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 require 'securerandom'
 

data/lib/rubyn_code/ide/handlers/prompt_handler.rb

@@ -57,7 +57,15 @@ module RubynCode
           return unless thread&.alive?
 
           thread.raise(Interrupt)
-          thread.join(2) # give it a moment to clean up
+          begin
+            thread.join(2) # give it a moment to clean up
+          rescue Interrupt
+            # We asked the thread to stop, so its Interrupt is expected. If it
+            # lands before the agent installs its own rescue, Thread#join would
+            # otherwise re-raise it into the caller (the cancel path) and, in
+            # tests, escape the example and abort the whole run.
+            nil
+          end
         end
 
         private

data/lib/rubyn_code/ide/handlers/recover_ci_handler.rb

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 require 'securerandom'
 
@@ -36,18 +36,34 @@ module RubynCode
         private
 
         def run_recovery(session_id, context)
+          notify_recovering(session_id, context)
+
+          recovery = @recovery || Megaplan::CiRecovery.new(
+            agent_invoker: build_invoker(session_id)
+          )
+          outcome = recovery.recover(context)
+
+          notify_outcome(session_id, context, outcome)
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done',
+                           'summary' => outcome['summary']
+                         })
+        rescue StandardError => e
+          warn "[RecoverCiHandler] error: #{e.message}"
+          notify_error(session_id, context, e)
+        end
+
+        def notify_recovering(session_id, context)
           @server.notify('agent/status', {
                            'sessionId' => session_id,
                            'status' => 'recovering',
                            'phaseNumber' => context['phase_number'],
                            'attemptNumber' => context['attempt_number']
                          })
+        end
 
-          recovery = @recovery || Megaplan::CiRecovery.new(
-            agent_invoker: build_invoker(session_id)
-          )
-          outcome = recovery.recover(context)
-
+        def notify_outcome(session_id, context, outcome)
           @server.notify('recovery/outcome', {
                            'sessionId' => session_id,
                            'planId' => context['plan_id'],
@@ -56,25 +72,20 @@ module RubynCode
                            'commitSha' => outcome['commit_sha'],
                            'summary' => outcome['summary']
                          })
+        end
 
-          @server.notify('agent/status', {
-                           'sessionId' => session_id,
-                           'status' => 'done',
-                           'summary' => outcome['summary']
-                         })
-        rescue StandardError => e
-          warn "[RecoverCiHandler] error: #{e.message}"
+        def notify_error(session_id, context, error)
           @server.notify('recovery/outcome', {
                            'sessionId' => session_id,
                            'planId' => context['plan_id'],
                            'phaseNumber' => context['phase_number'],
                            'kind' => 'errored',
-                           'summary' => e.message
+                           'summary' => error.message
                          })
           @server.notify('agent/status', {
                            'sessionId' => session_id,
                            'status' => 'error',
-                           'error' => e.message
+                           'error' => error.message
                          })
         end
 
@@ -87,7 +98,7 @@ module RubynCode
             llm_client = LLM::Client.new
             response = llm_client.chat(
               messages: [{ role: 'user', content: prompt }],
-              on_text: ->(text) {
+              on_text: lambda { |text|
                 @server.notify('stream/text', {
                                  'sessionId' => session_id,
                                  'text' => text,

data/lib/rubyn_code/ide/handlers/session_resume_handler.rb

@@ -30,7 +30,7 @@ module RubynCode
           prompt = @server.handler_instance(:prompt)
           if prompt
             conversation = Agent::Conversation.new
-            messages.each { |msg| conversation.messages << msg }
+            conversation.replace!(messages.dup)
             prompt.inject_conversation(session_id, conversation)
           end
 

data/lib/rubyn_code/index/codebase_index.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'fileutils'
+require 'open3'
 
 module RubynCode
   module Index
@@ -42,7 +43,9 @@ module RubynCode
 
         data = JSON.parse(File.read(@index_path))
         @nodes = data['nodes'] || []
-        @edges = data['edges'] || []
+        # uniq drops duplicate edges accumulated by older versions, which
+        # appended tests edges on every update! without dedup.
+        @edges = (data['edges'] || []).uniq
         @file_mtimes = data['file_mtimes'] || {}
         self
       rescue StandardError
@@ -69,6 +72,19 @@ module RubynCode
         self
       end
 
+      # Incremental update for a single known-changed file (e.g. after a
+      # write_file/edit_file tool call). Avoids the full-tree scan in update!.
+      def update_file!(path)
+        absolute = File.expand_path(path, @project_root)
+        return self unless absolute.start_with?("#{@project_root}/")
+
+        remove_nodes_for(absolute)
+        index_file(absolute) if File.exist?(absolute)
+        extract_rails_edges
+        save!
+        self
+      end
+
       # Query the index for symbols matching a search term.
       def query(term)
         pattern = term.to_s.downcase
@@ -192,6 +208,26 @@ module RubynCode
       end
 
       def ruby_files
+        git_ruby_files || glob_ruby_files
+      end
+
+      # Prefer git's file list when available: it skips ignored dirs
+      # (tmp/, log/, coverage/, db/) the glob would index. --others picks up
+      # untracked-but-not-ignored files so freshly created ones still appear.
+      def git_ruby_files
+        return nil unless File.exist?(File.join(@project_root, '.git'))
+
+        stdout, status = Open3.capture2(
+          'git', '-C', @project_root, 'ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', '*.rb'
+        )
+        return nil unless status.success?
+
+        stdout.split("\0").map { |f| File.join(@project_root, f) }.select { |f| File.file?(f) }
+      rescue StandardError
+        nil
+      end
+
+      def glob_ruby_files
         Dir.glob(File.join(@project_root, '**', '*.rb'))
            .reject { |f| f.include?('/vendor/') || f.include?('/node_modules/') }
       end
@@ -253,6 +289,8 @@ module RubynCode
       end
 
       def extract_rails_edges
+        # Rebuild tests edges from scratch so repeated updates stay idempotent.
+        @edges.reject! { |e| e['relationship'] == 'tests' }
         spec_files = @file_mtimes.keys.select { |f| f.include?('spec/') || f.include?('test/') }
         spec_files.each do |spec_file|
           source = spec_file.sub(%r{spec/}, 'app/').sub(/_spec\.rb$/, '.rb')

data/lib/rubyn_code/learning/porter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+
+module RubynCode
+  module Learning
+    # Exports and imports learned instincts so a user can carry their
+    # accumulated learnings to another machine. Instincts live in SQLite under
+    # ~/.rubyn-code; this serializes them to a portable JSON file and loads
+    # them back, regenerating ids and de-duplicating by (project_path, pattern).
+    module Porter
+      FORMAT_VERSION = 1
+      # Columns carried across machines (id is regenerated on import).
+      COLUMNS = %w[
+        project_path pattern context_tags confidence decay_rate
+        times_applied times_helpful created_at updated_at
+      ].freeze
+
+      class Error < RubynCode::Error; end
+
+      class << self
+        # Export instincts to a JSON file.
+        #
+        # @param db [DB::Connection]
+        # @param path [String] destination file
+        # @param project_path [String, nil] limit to one project, or nil for all
+        # @return [Integer] number of instincts exported
+        def export(db:, path:, project_path: nil)
+          rows = fetch(db, project_path)
+          payload = { 'version' => FORMAT_VERSION, 'instincts' => rows }
+          File.write(path, "#{JSON.pretty_generate(payload)}\n")
+          rows.size
+        end
+
+        # Import instincts from a JSON file.
+        #
+        # @param db [DB::Connection]
+        # @param path [String] source file
+        # @param remap_project [String, nil] override every row's project_path
+        #   (use the current project so imported learnings apply here)
+        # @return [Hash] { imported:, skipped:, total: }
+        def import(db:, path:, remap_project: nil)
+          raise Error, "File not found: #{path}" unless File.file?(path)
+
+          payload = parse(path)
+          instincts = Array(payload['instincts'])
+          imported = instincts.count { |row| import_row(db, row, remap_project) }
+
+          { imported: imported, skipped: instincts.size - imported, total: instincts.size }
+        end
+
+        # @return [Hash] { count:, projects: } summary for display
+        def stats(db, project_path: nil)
+          rows = fetch(db, project_path)
+          { count: rows.size, projects: rows.map { |r| r['project_path'] }.uniq.size }
+        end
+
+        private
+
+        def fetch(db, project_path)
+          select = "SELECT #{COLUMNS.join(', ')} FROM instincts"
+          if project_path
+            db.query("#{select} WHERE project_path = ?", [project_path]).to_a
+          else
+            db.query(select).to_a
+          end
+        end
+
+        def parse(path)
+          payload = JSON.parse(File.read(path))
+          raise Error, 'Not a Rubyn learnings file' unless payload.is_a?(Hash) && payload.key?('instincts')
+
+          version = payload['version'].to_i
+          raise Error, "Unsupported export version: #{version}" if version > FORMAT_VERSION
+
+          payload
+        rescue JSON::ParserError => e
+          raise Error, "Invalid JSON: #{e.message}"
+        end
+
+        # @return [Boolean] true if inserted, false if skipped (duplicate)
+        def import_row(db, row, remap_project)
+          project = remap_project || row['project_path']
+          return false if project.to_s.empty? || row['pattern'].to_s.empty?
+          return false if exists?(db, project, row['pattern'])
+
+          insert(db, row, project)
+          true
+        rescue StandardError => e
+          RubynCode::Debug.warn("Skipping instinct import: #{e.message}")
+          false
+        end
+
+        def exists?(db, project, pattern)
+          db.query(
+            'SELECT 1 FROM instincts WHERE project_path = ? AND pattern = ? LIMIT 1',
+            [project, pattern]
+          ).to_a.any?
+        end
+
+        def insert(db, row, project)
+          now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+          db.execute(
+            <<~SQL.tr("\n", ' ').strip,
+              INSERT INTO instincts (id, project_path, pattern, context_tags,
+                confidence, decay_rate, times_applied, times_helpful, created_at, updated_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            SQL
+            [
+              SecureRandom.uuid, project, row['pattern'], normalize_tags(row['context_tags']),
+              (row['confidence'] || 0.5).to_f, (row['decay_rate'] || 0.05).to_f,
+              (row['times_applied'] || 0).to_i, (row['times_helpful'] || 0).to_i,
+              row['created_at'] || now, row['updated_at'] || now
+            ]
+          )
+        end
+
+        # context_tags is stored as a JSON string column; accept either a JSON
+        # string or an array from the export file.
+        def normalize_tags(tags)
+          return tags if tags.is_a?(String)
+
+          JSON.generate(Array(tags))
+        end
+      end
+    end
+  end
+end