rubyn-code 0.5.1 → 0.8.0

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
@@ -13,6 +14,9 @@ module RubynCode
       INDEX_DIR = '.rubyn-code'
       INDEX_FILE = 'codebase_index.json'
       CHARS_PER_TOKEN = 4
+      # Bump when the stored shape changes so stale indexes rebuild instead
+      # of silently serving degraded data. 2 = Prism spans + call edges.
+      FORMAT_VERSION = 2
 
       attr_reader :nodes, :edges, :index_path
 
@@ -32,6 +36,7 @@ module RubynCode
 
         ruby_files.each { |file| index_file(file) }
         extract_rails_edges
+        prune_call_edges!
         save!
         self
       end
@@ -41,8 +46,12 @@ module RubynCode
         return nil unless File.exist?(@index_path)
 
         data = JSON.parse(File.read(@index_path))
+        return nil unless data['format_version'] == FORMAT_VERSION
+
         @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
@@ -65,6 +74,21 @@ module RubynCode
         end
 
         extract_rails_edges
+        prune_call_edges!
+        save!
+        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
+        prune_call_edges!
         save!
         self
       end
@@ -192,6 +216,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
@@ -201,14 +245,66 @@ module RubynCode
         content = File.read(file)
         @file_mtimes[relative] = File.mtime(file).to_i
 
-        extract_classes(content, relative)
-        extract_methods(content, relative)
+        extract_symbols(content, relative)
         extract_associations(content, relative)
         extract_rails_patterns(content, relative)
       rescue StandardError => e
         RubynCode::Debug.warn("Index: failed to parse #{file}: #{e.message}")
       end
 
+      # Prism gives real line spans (needed for verbatim source in code_graph)
+      # and call edges. Files that don't parse fall back to the regex pass,
+      # which produces the same node shapes minus end_line/owner/calls.
+      def extract_symbols(content, file)
+        extracted = PrismExtractor.extract(content)
+        unless extracted
+          extract_classes(content, file)
+          extract_methods(content, file)
+          return
+        end
+
+        add_class_nodes(extracted.classes, file)
+        add_method_nodes(extracted.defs, file)
+        add_call_edges(extracted.calls, file)
+      end
+
+      def add_class_nodes(classes, file)
+        classes.each do |c|
+          @nodes << {
+            'type' => classify_node(file, c[:kind]), 'name' => c[:name],
+            'file' => file, 'line' => c[:line], 'end_line' => c[:end_line]
+          }
+        end
+      end
+
+      def add_method_nodes(methods, file)
+        methods.each do |m|
+          @nodes << {
+            'type' => 'method', 'name' => m[:name], 'file' => file,
+            'line' => m[:line], 'end_line' => m[:end_line],
+            'owner' => m[:owner], 'params' => m[:params], 'visibility' => 'public'
+          }
+        end
+      end
+
+      # `from` stays the file path so remove_nodes_for's from-based cleanup
+      # applies to call edges too; the calling method rides in from_method.
+      def add_call_edges(calls, file)
+        calls.each do |c|
+          @edges << {
+            'from' => file, 'from_method' => c[:from], 'to' => c[:to],
+            'relationship' => 'calls', 'line' => c[:line]
+          }
+        end
+      end
+
+      # Drop call edges whose target isn't defined in the project — filters
+      # out stdlib/gem calls (puts, map, ...) that would swamp the graph.
+      def prune_call_edges!
+        defined_methods = @nodes.filter_map { |n| n['name'] if n['type'] == 'method' }.to_set
+        @edges.reject! { |e| e['relationship'] == 'calls' && !defined_methods.include?(e['to']) }
+      end
+
       def extract_classes(content, file)
         content.scan(/^\s*(class|module)\s+(\S+)/).each do |type, name|
           node_type = classify_node(file, type)
@@ -253,6 +349,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')
@@ -304,7 +402,8 @@ module RubynCode
 
       def save!
         FileUtils.mkdir_p(File.dirname(@index_path))
-        data = { 'nodes' => @nodes, 'edges' => @edges, 'file_mtimes' => @file_mtimes }
+        data = { 'format_version' => FORMAT_VERSION, 'nodes' => @nodes, 'edges' => @edges,
+                 'file_mtimes' => @file_mtimes }
         File.write(@index_path, JSON.generate(data))
       end
     end

data/lib/rubyn_code/index/prism_extractor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module RubynCode
+  module Index
+    # Prism-based symbol and call extractor for a single Ruby file.
+    # Returns classes/modules and methods with real line spans, plus
+    # method-to-method call sites the regex pass can't see. Used by
+    # CodebaseIndex, with the regex extractors as a parse-error fallback.
+    class PrismExtractor < Prism::Visitor
+      Result = Struct.new(:classes, :defs, :calls)
+
+      # @return [Result, nil] nil when the file doesn't parse
+      def self.extract(content)
+        parsed = Prism.parse(content)
+        return nil unless parsed.success?
+
+        visitor = new
+        visitor.visit(parsed.value)
+        Result.new(visitor.classes, visitor.defs, visitor.calls)
+      rescue StandardError
+        nil
+      end
+
+      attr_reader :classes, :defs, :calls
+
+      def initialize
+        super
+        @namespace = []
+        @current_def = nil
+        @classes = [] # { name:, kind:, line:, end_line: }
+        @defs    = [] # { name:, owner:, line:, end_line:, params: }
+        @calls   = [] # { from:, to:, line: }
+      end
+
+      def visit_class_node(node)
+        record_namespace(node, 'class') { super }
+      end
+
+      def visit_module_node(node)
+        record_namespace(node, 'module') { super }
+      end
+
+      def visit_def_node(node)
+        @defs << {
+          name: node.name.to_s,
+          owner: @namespace.join('::'),
+          line: node.location.start_line,
+          end_line: node.location.end_line,
+          params: node.parameters ? "(#{node.parameters.slice})" : nil
+        }
+        previous = @current_def
+        @current_def = node.name.to_s
+        super
+        @current_def = previous
+      end
+
+      # ponytail: resolution is by method name, not receiver type — a call to
+      # `user.save` links to any `save` defined in the project. Real receiver
+      # inference needs type analysis; name matching covers the common case.
+      def visit_call_node(node)
+        @calls << { from: @current_def, to: node.name.to_s, line: node.location.start_line } if @current_def
+        super
+      end
+
+      private
+
+      # The block continues the walk into child nodes (the caller's `super`).
+      def record_namespace(node, kind)
+        name = node.constant_path.slice
+        @classes << {
+          name: name, kind: kind,
+          line: node.location.start_line, end_line: node.location.end_line
+        }
+        @namespace.push(name)
+        yield
+        @namespace.pop
+      end
+    end
+  end
+end

data/lib/rubyn_code/learning/injector.rb

@@ -112,8 +112,7 @@ module RubynCode
           tag_set = tags.to_set(&:downcase)
 
           instincts.select do |inst|
-            inst_tags = inst.context_tags.map(&:downcase)
-            inst_tags.any? { |t| tag_set.include?(t) }
+            inst.context_tags.any? { |t| tag_set.include?(t.downcase) }
           end
         end
 

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