legionio 1.4.126 → 1.4.129

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d967d6f545da4301ebb7175d8e5ede497549f476f9a590b04b769cf61fa09e7
-  data.tar.gz: 6d56d3fe6e686cb04e99bc5fd82962303e3a79b0c87447bc253193d917aad601
+  metadata.gz: 77260f7b11e2e6274661a661d12c0c09b97a854faf0366b58ac49fcd31485a63
+  data.tar.gz: b2164cc013bc8265a421dba4f2a35ae66808d871725b73db68c58344d22b3068
 SHA512:
-  metadata.gz: 5d5472ede458093d44ddcb48effafdfdfacd60b75b3eda88500e849eb18d13b5ab2cff54b086321c088e511ee9f53bce4a40f4f8b5ca03d3dec0dfd75f8c91e0
-  data.tar.gz: ae7bbda82bc87982a24032475919d21351c67613414fb397ed4e839a191ccc99a3d1446b168c0fc92603836ef43fde6793642f283eecb6f7ef902cc221cff1b3
+  metadata.gz: 6a04b0dbe4ccf7b78a5c2ea2423675ab29c41d1804d0c12527a878276c6d1b2febe511a15ee8c137ba114b3f318f9ed74b91ebeb11041983043e0d6f0f61f5ea
+  data.tar.gz: b4a04e1b34802584b2241dc31b105fae654043c881daa1bc264001548d9f0358a6131bac8dd4679654fac959c126bf24ac4bfe55b569679d05218b031cce2742

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Legion Changelog
 
+## [1.4.129] - 2026-03-22
+
+### Added
+- SearchTraces chat tool for querying cognitive memory traces (Teams messages, conversations, meetings, people)
+- Keyword-ranked search with person, domain, and trace type filtering
+- Structured output formatting with age, strength, and domain tag metadata
+
+## [1.4.128] - 2026-03-22
+
+### Changed
+- `Extensions::Helpers::Cache` now delegates to `Legion::Cache::Helper` from legion-cache gem
+- Require legion-cache >= 1.3.11 and legion-crypt >= 1.4.9
+
+## [1.4.127] - 2026-03-22
+
+### Changed
+- `Extensions::Helpers::Core` now delegates `settings` to `Legion::Settings::Helper` from legion-settings gem
+- Require legion-settings >= 1.3.14 for the new Helper module
+
 ## [1.4.126] - 2026-03-22
 
 ### Changed

data/legionio.gemspec

@@ -52,11 +52,11 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', '>= 1.3'
   spec.add_dependency 'tty-spinner', '~> 0.9'
 
-  spec.add_dependency 'legion-cache', '>= 1.3.9'
-  spec.add_dependency 'legion-crypt', '>= 1.4.8'
+  spec.add_dependency 'legion-cache', '>= 1.3.11'
+  spec.add_dependency 'legion-crypt', '>= 1.4.9'
   spec.add_dependency 'legion-json', '>= 1.2.0'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
-  spec.add_dependency 'legion-settings', '>= 1.3.12'
+  spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.3.6'
 
   spec.add_dependency 'legion-tty', '>= 0.4.30'

data/lib/legion/cli/chat/tool_registry.rb

@@ -15,6 +15,7 @@ begin
   require 'legion/cli/chat/tools/search_memory'
   require 'legion/cli/chat/tools/web_search'
   require 'legion/cli/chat/tools/spawn_agent'
+  require 'legion/cli/chat/tools/search_traces'
 rescue LoadError => e
   Legion::Logging.debug("ToolRegistry ruby_llm not available, chat tools will not be registered: #{e.message}") if defined?(Legion::Logging)
 end
@@ -36,7 +37,8 @@ module Legion
                             Tools::SaveMemory,
                             Tools::SearchMemory,
                             Tools::WebSearch,
-                            Tools::SpawnAgent
+                            Tools::SpawnAgent,
+                            Tools::SearchTraces
                           ].freeze
                         else
                           [].freeze

data/lib/legion/cli/chat/tools/search_traces.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'ruby_llm'
+require 'json'
+require 'legion/cli/chat_command'
+
+module Legion
+  module CLI
+    class Chat
+      module Tools
+        class SearchTraces < RubyLLM::Tool
+          description 'Search cognitive memory traces for information from Teams messages, conversations, ' \
+                      'meetings, people, and other ingested data. Use this when the user asks about what ' \
+                      'someone said, conversation topics, meeting details, or any previously observed context.'
+          param :query, type: 'string', desc: 'Natural language search query (e.g., "what did Bob say about deployment")'
+          param :person, type: 'string', desc: 'Filter by person name (matches peer:Name domain tags)', required: false
+          param :domain, type: 'string', desc: 'Filter by domain tag (e.g., "teams", "meeting", "conversation")', required: false
+          param :trace_type, type: 'string', desc: 'Filter by trace type: episodic, semantic, sensory, identity', required: false
+          param :limit, type: 'integer', desc: 'Max results to return (default: 20)', required: false
+
+          STRUCTURED_FIELDS = [
+            ['Person', 'displayName', :displayName, 'peer', :peer],
+            ['Summary', 'summary', :summary],
+            ['Subject', 'subject', :subject],
+            ['Team', 'team', :team],
+            ['Job', 'jobTitle', :jobTitle]
+          ].freeze
+
+          def execute(query:, person: nil, domain: nil, trace_type: nil, limit: nil)
+            return 'Memory trace system not available (lex-agentic-memory not loaded).' unless trace_store_available?
+
+            limit = (limit || 20).clamp(1, 50)
+            traces = collect_traces(person: person, domain: domain, trace_type: trace_type, limit: limit * 3)
+            return 'No memory traces found matching those filters.' if traces.empty?
+
+            ranked = rank_by_query(traces: traces, query: query)
+            results = ranked.first(limit)
+            return 'No traces matched your query.' if results.empty?
+
+            format_results(results)
+          rescue StandardError => e
+            Legion::Logging.warn("SearchTraces#execute failed: #{e.message}") if defined?(Legion::Logging)
+            "Error searching traces: #{e.message}"
+          end
+
+          private
+
+          def trace_store_available?
+            defined?(Legion::Extensions::Agentic::Memory::Trace) &&
+              Legion::Extensions::Agentic::Memory::Trace.respond_to?(:shared_store)
+          end
+
+          def store
+            Legion::Extensions::Agentic::Memory::Trace.shared_store
+          end
+
+          def collect_traces(person:, domain:, trace_type:, limit:)
+            if person
+              tag = "peer:#{person}"
+              candidates = store.retrieve_by_domain(tag, min_strength: 0.01, limit: limit)
+              candidates += store.retrieve_by_domain('teams', min_strength: 0.01, limit: limit) if candidates.size < 5
+              return candidates.uniq { |t| t[:trace_id] }
+            end
+
+            return store.retrieve_by_domain(domain, min_strength: 0.01, limit: limit) if domain
+
+            if trace_type
+              sym = trace_type.to_sym
+              return store.retrieve_by_type(sym, min_strength: 0.01, limit: limit)
+            end
+
+            store.all_traces(min_strength: 0.01).sort_by { |t| -t[:strength] }.first(limit)
+          end
+
+          def rank_by_query(traces:, query:)
+            keywords = query.downcase.split(/\s+/).reject { |w| w.length < 3 }
+            return traces if keywords.empty?
+
+            scored = traces.filter_map do |trace|
+              text = extract_searchable_text(trace)
+              next nil if text.empty?
+
+              score = compute_score(text: text, keywords: keywords, trace: trace)
+              next nil if score.zero?
+
+              { trace: trace, score: score }
+            end
+
+            scored.sort_by { |s| -s[:score] }.map { |s| s[:trace] }
+          end
+
+          def extract_searchable_text(trace)
+            payload = trace[:content_payload] || trace[:content]
+            text = case payload
+                   when String
+                     begin
+                       parsed = ::JSON.parse(payload)
+                       flatten_to_text(parsed)
+                     rescue ::JSON::ParserError
+                       payload
+                     end
+                   when Hash
+                     flatten_to_text(payload)
+                   else
+                     payload.to_s
+                   end
+            text.downcase
+          end
+
+          def flatten_to_text(obj)
+            case obj
+            when Hash
+              obj.values.map { |v| flatten_to_text(v) }.join(' ')
+            when Array
+              obj.map { |v| flatten_to_text(v) }.join(' ')
+            else
+              obj.to_s
+            end
+          end
+
+          def compute_score(text:, keywords:, trace:)
+            keyword_hits = keywords.count { |kw| text.include?(kw) }
+            return 0.0 if keyword_hits.zero?
+
+            keyword_ratio = keyword_hits.to_f / keywords.size
+            strength_bonus = trace[:strength] || 0.0
+            recency_bonus = recency_score(trace[:created_at])
+
+            (keyword_ratio * 10.0) + (strength_bonus * 2.0) + (recency_bonus * 3.0)
+          end
+
+          def recency_score(created_at)
+            return 0.0 unless created_at.is_a?(Time)
+
+            age_hours = (Time.now.utc - created_at) / 3600.0
+            1.0 / (1.0 + (age_hours / 24.0))
+          end
+
+          def format_results(traces)
+            parts = traces.map.with_index(1) do |trace, idx|
+              payload = trace[:content_payload] || trace[:content]
+              content = format_payload(payload)
+              tags = (trace[:domain_tags] || []).join(', ')
+              age = format_age(trace[:created_at])
+
+              "#{idx}. [#{trace[:trace_type]}] #{content}\n   tags: #{tags} | strength: #{(trace[:strength] || 0).round(2)} | #{age}"
+            end
+
+            "Found #{traces.size} matching traces:\n\n#{parts.join("\n\n")}"
+          end
+
+          def format_payload(payload)
+            data = parse_payload(payload)
+            return truncate(data, 300) if data.is_a?(String)
+
+            format_structured(data)
+          end
+
+          def parse_payload(payload)
+            case payload
+            when String
+              ::JSON.parse(payload)
+            when Hash
+              payload
+            else
+              payload.to_s
+            end
+          rescue ::JSON::ParserError
+            payload
+          end
+
+          def format_structured(data)
+            parts = STRUCTURED_FIELDS.filter_map do |label, *keys|
+              val = keys.lazy.filter_map { |k| data[k] }.first
+              "#{label}: #{val}" if val
+            end
+
+            return parts.join(' | ') unless parts.empty?
+
+            truncate(flatten_to_text(data), 300)
+          end
+
+          def truncate(text, max)
+            text.length > max ? "#{text[0..(max - 3)]}..." : text
+          end
+
+          def format_age(created_at)
+            return 'age unknown' unless created_at.is_a?(Time)
+
+            seconds = Time.now.utc - created_at
+            if seconds < 3600
+              "#{(seconds / 60).to_i}m ago"
+            elsif seconds < 86_400
+              "#{(seconds / 3600).to_i}h ago"
+            else
+              "#{(seconds / 86_400).to_i}d ago"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/helpers/cache.rb

@@ -1,24 +1,14 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/helpers/base'
+require 'legion/cache/helper'
 
 module Legion
   module Extensions
     module Helpers
       module Cache
         include Legion::Extensions::Helpers::Base
-
-        def cache_namespace
-          @cache_namespace ||= lex_name
-        end
-
-        def cache_set(key, value, ttl: 60, **)
-          Legion::Cache.set(cache_namespace + key, value, ttl: ttl)
-        end
-
-        def cache_get(key)
-          Legion::Cache.get(cache_namespace + key)
-        end
+        include Legion::Cache::Helper
       end
     end
   end

data/lib/legion/extensions/helpers/core.rb

@@ -1,19 +1,14 @@
 # frozen_string_literal: true
 
 require_relative 'base'
+require 'legion/settings/helper'
+
 module Legion
   module Extensions
     module Helpers
       module Core
         include Legion::Extensions::Helpers::Base
-
-        def settings
-          if Legion::Settings[:extensions].key?(lex_filename.to_sym)
-            Legion::Settings[:extensions][lex_filename.to_sym]
-          else
-            { logger: { level: 'info', extended: false, internal: false } }
-          end
-        end
+        include Legion::Settings::Helper
 
         # looks local, then in crypt, then settings, then cache, then env
         def find_setting(name, **opts)

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.4.126'
+  VERSION = '1.4.129'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.126
+  version: 1.4.129
 platform: ruby
 authors:
 - Esity
@@ -225,28 +225,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.9
+        version: 1.3.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.9
+        version: 1.3.11
 - !ruby/object:Gem::Dependency
   name: legion-crypt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.8
+        version: 1.4.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.8
+        version: 1.4.9
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -281,14 +281,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.12
+        version: 1.3.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.12
+        version: 1.3.14
 - !ruby/object:Gem::Dependency
   name: legion-transport
   requirement: !ruby/object:Gem::Requirement
@@ -474,6 +474,7 @@ files:
 - lib/legion/cli/chat/tools/search_content.rb
 - lib/legion/cli/chat/tools/search_files.rb
 - lib/legion/cli/chat/tools/search_memory.rb
+- lib/legion/cli/chat/tools/search_traces.rb
 - lib/legion/cli/chat/tools/spawn_agent.rb
 - lib/legion/cli/chat/tools/web_search.rb
 - lib/legion/cli/chat/tools/write_file.rb