lex-microsoft_teams 0.6.20 → 0.6.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: beeb83d06cdfce621a29d635ac797893d31d9d8403c88a488ee076b278d4a87c
-  data.tar.gz: 759f1937d7693a07e1ad6fa5172583f9d13c58eadce7c12aac3eb42cfb0c75c1
+  metadata.gz: cc24206d1c97c648d8c3cf0b5ab0acac653195153903e901e1d89e89445b6618
+  data.tar.gz: 5768ef9650b4bc861d193c8477e80f2e96962501c11246aaf1178b00c43f1432
 SHA512:
-  metadata.gz: da442c0b860020406dd65a43b5e6ef9928b0f45e7123709fc2340e81b7288a0a8b94a7e6bb7781bde4c64bc8e071dfcc96b2e24a9b60a0974dc540e3454fd41c
-  data.tar.gz: dcf5a9cf6e7d8a9171131833588b9a41fa5a7a864dc26681b9eee0b31cd6da0e841456d84aefa153dfac51bf16f07350cad3eeed04702f4d85a1376ac062da54
+  metadata.gz: eb531084dcff80d75c9e624ab02f2db647d18758cf7621f7ee3ea8f79be593b5db2d4297aef2ac716aba394a76945e766ee13015b4558ed50b57dacc401d4fff
+  data.tar.gz: f7e5df0a0e9b251043b14e1dac114c24c797b23fc8097402508bfacf326f6903f125ffcbd6df474b9927542b2ba4fd123d8aabf9355ac3b302a1b47cb2510694

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed
+- `Absorbers::Meeting#graph_token` — rescue now captures the exception as `=> e` and logs a warning, satisfying the rescue-logging lint rule
+
+## [0.6.23] - 2026-03-27
+
+### Changed
+- `Absorbers::Meeting` — all Graph API runner calls now pass `token: graph_token` so requests carry an `Authorization` header in production. `graph_token` resolves from `Helpers::TokenCache.instance.cached_graph_token` when available, falling back to `nil` (unauthenticated) with a rescued `StandardError` to prevent test-environment boot failures
+- `CLAUDE.md` — version field updated to 0.6.23
+
+## [0.6.22] - 2026-03-27
+
+### Changed
+- `Absorbers::Meeting#handle` now fails fast with `{ success: false, error: 'meeting has no id' }` when the resolved meeting item has no `id` field, preventing subsequent runner calls from building invalid URLs
+- `spec/legion/extensions/microsoft_teams/absorbers/meeting_spec.rb` — added spec covering the blank `meeting_id` guard path
+
+## [0.6.21] - 2026-03-27
+
+### Added
+- `Absorbers::Meeting` — reference implementation of the absorber framework for Teams meetings. Resolves a Teams join URL to a meeting via Graph API, then ingests transcripts (VTT), AI insights, and participant lists into Apollo knowledge store. Two URL patterns registered: `teams.microsoft.com/l/meetup-join/*` and `*.teams.microsoft.com/meet/*`. Guard on `Legion::Extensions::Absorbers` ensures the absorber only loads when the framework base class is available.
+- `spec/spec_helper.rb` — inline stubs for `Legion::Extensions::Absorbers::Base` and `Matchers::Url` so absorber specs run without the full `legionio` gem in the test environment
+
+### Changed
+- `lib/legion/extensions/microsoft_teams/absorbers/meeting.rb` — runner calls now go through `meetings_runner`, `transcripts_runner`, and `ai_insights_runner` instance accessors (`Object.new.extend(Runners::*)`) instead of calling runner modules directly as class methods, which would raise `NoMethodError` at runtime
+- `spec/legion/extensions/microsoft_teams/absorbers/meeting_spec.rb` — specs stub runner instances via `absorber.meetings_runner` / `absorber.transcripts_runner` / `absorber.ai_insights_runner` rather than the module constants; `.patterns` spec no longer relies on `patterns.first` ordering; now asserts both expected pattern values are present in the set
+
 ## [0.6.19] - 2026-03-26
 
 ### Changed

data/CLAUDE.md

@@ -10,7 +10,7 @@ Legion Extension that connects LegionIO to Microsoft Teams via Graph API and Bot
 
 **GitHub**: https://github.com/LegionIO/lex-microsoft_teams
 **License**: MIT
-**Version**: 0.6.18
+**Version**: 0.6.23
 
 ## Architecture
 

data/lib/legion/extensions/microsoft_teams/absorbers/meeting.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Absorbers
+        class Meeting < Legion::Extensions::Absorbers::Base
+          pattern :url, 'teams.microsoft.com/l/meetup-join/*'
+          pattern :url, '*.teams.microsoft.com/meet/*'
+          description 'Absorbs Teams meeting transcripts, AI insights, and participants into Apollo'
+
+          def handle(url: nil, content: nil, metadata: {}, context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            report_progress(message: 'resolving meeting from link')
+            meeting = resolve_meeting(url)
+            return { success: false, error: 'could not resolve meeting' } unless meeting
+
+            subject    = meeting['subject'] || meeting[:subject] || 'untitled meeting'
+            meeting_id = meeting['id'] || meeting[:id]
+            return { success: false, error: 'meeting has no id' } if meeting_id.nil? || meeting_id.to_s.empty?
+
+            results = { meeting_id: meeting_id, subject: subject, chunks: 0 }
+
+            ingest_transcript(meeting_id, subject, results)
+            ingest_ai_insights(meeting_id, subject, results)
+            ingest_participants(meeting, subject, results)
+
+            report_progress(message: 'done', percent: 100)
+            results.merge(success: true)
+          rescue StandardError => e
+            log.error("Meeting absorber failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def meetings_runner
+            @meetings_runner ||= Object.new.extend(Runners::Meetings)
+          end
+
+          def transcripts_runner
+            @transcripts_runner ||= Object.new.extend(Runners::Transcripts)
+          end
+
+          def ai_insights_runner
+            @ai_insights_runner ||= Object.new.extend(Runners::AiInsights)
+          end
+
+          def graph_token
+            return @graph_token if defined?(@graph_token)
+
+            @graph_token = begin
+              Helpers::TokenCache.instance.cached_graph_token if defined?(Helpers::TokenCache)
+            rescue StandardError => e
+              log.warn("graph_token unavailable: #{e.message}")
+              nil
+            end
+          end
+
+          def resolve_meeting(url)
+            report_progress(message: 'looking up meeting by join URL', percent: 5)
+            response = meetings_runner.get_meeting_by_join_url(join_url: url, token: graph_token)
+            return nil unless response.is_a?(Hash)
+
+            body = response[:result]
+            return nil unless body.is_a?(Hash)
+
+            items = body['value'] || body[:value]
+            return nil unless items.is_a?(Array) && !items.empty?
+
+            items.first
+          rescue StandardError => e
+            log.warn("Could not resolve meeting: #{e.message}")
+            nil
+          end
+
+          def ingest_transcript(meeting_id, subject, results)
+            report_progress(message: 'fetching transcripts', percent: 20)
+            transcripts_response = transcripts_runner.list_transcripts(meeting_id: meeting_id, token: graph_token)
+            transcripts_body     = transcripts_response.is_a?(Hash) ? transcripts_response[:result] : nil
+            return unless transcripts_body.is_a?(Hash)
+
+            transcript_items = transcripts_body['value'] || transcripts_body[:value]
+            return unless transcript_items.is_a?(Array) && transcript_items.any?
+
+            transcript_items.each do |t|
+              transcript_id = t['id'] || t[:id]
+              next unless transcript_id
+
+              report_progress(message: "pulling transcript #{transcript_id}", percent: 40)
+              vtt_result = transcripts_runner.get_transcript_content(
+                meeting_id: meeting_id, transcript_id: transcript_id, format: :vtt, token: graph_token
+              )
+              vtt = vtt_result.is_a?(Hash) ? vtt_result[:result] : vtt_result
+              next unless vtt.is_a?(String) && !vtt.empty?
+
+              absorb_to_knowledge(
+                content:      vtt,
+                tags:         ['meeting', 'transcript', subject],
+                source_file:  "teams://meetings/#{meeting_id}/transcripts/#{transcript_id}",
+                heading:      "Transcript: #{subject}",
+                content_type: 'meeting_transcript'
+              )
+              results[:chunks] += 1
+            end
+          rescue StandardError => e
+            log.warn("Transcript ingest failed: #{e.message}")
+          end
+
+          def ingest_ai_insights(meeting_id, subject, results)
+            report_progress(message: 'fetching AI insights', percent: 60)
+            insights = ai_insights_runner.list_meeting_ai_insights(meeting_id: meeting_id, token: graph_token)
+            return unless insights.is_a?(Hash)
+
+            body  = insights[:result] || insights
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return unless items.is_a?(Array) && items.any?
+
+            items.each { |item| absorb_insight_item(item, meeting_id, subject, results) }
+          rescue StandardError => e
+            log.warn("AI insights ingest failed: #{e.message}")
+          end
+
+          def absorb_insight_item(item, meeting_id, subject, results)
+            return unless item.is_a?(Hash)
+
+            insight_id   = item['id'] || item[:id]
+            action_items = item['actionItems'] || item[:actionItems] || []
+            return if action_items.empty?
+
+            content = action_items.filter_map { |a| a.is_a?(Hash) ? (a['text'] || a[:text]) : a.to_s }.join("\n")
+            return if content.empty?
+
+            absorb_to_knowledge(
+              content:      content,
+              tags:         ['meeting', 'ai-insight', 'action-item', subject],
+              source_file:  "teams://meetings/#{meeting_id}/insights/#{insight_id}",
+              heading:      "AI Insight: #{subject}",
+              content_type: 'meeting_insight'
+            )
+            results[:chunks] += 1
+          end
+
+          def ingest_participants(meeting, subject, results)
+            report_progress(message: 'recording participants', percent: 80)
+            participants = meeting.dig('participants', 'attendees') || meeting.dig(:participants, :attendees)
+            return unless participants.is_a?(Array) && participants.any?
+
+            names = participants.filter_map do |p|
+              p.dig('identity', 'user', 'displayName') || p.dig(:identity, :user, :displayName)
+            end
+            return if names.empty?
+
+            meeting_id = meeting['id'] || meeting[:id]
+            absorb_raw(
+              content:      "Meeting participants for '#{subject}': #{names.join(', ')}",
+              tags:         ['meeting', 'participants', subject],
+              content_type: 'meeting_participants',
+              metadata:     { meeting_id: meeting_id, participant_count: names.length }
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("Participant ingest failed: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.20'
+      VERSION = '0.6.23'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -43,6 +43,12 @@ end
 
 require 'legion/extensions/microsoft_teams/client'
 
+if defined?(Legion::Extensions) &&
+   Legion::Extensions.const_defined?(:Absorbers, false) &&
+   Legion::Extensions::Absorbers.const_defined?(:Base, false)
+  require_relative 'microsoft_teams/absorbers/meeting'
+end
+
 module Legion
   module Extensions
     module MicrosoftTeams

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.20
+  version: 0.6.23
 platform: ruby
 authors:
 - Esity
@@ -175,6 +175,7 @@ files:
 - docs/plans/2026-03-19-teams-token-lifecycle-implementation.md
 - lex-microsoft_teams.gemspec
 - lib/legion/extensions/microsoft_teams.rb
+- lib/legion/extensions/microsoft_teams/absorbers/meeting.rb
 - lib/legion/extensions/microsoft_teams/actors/api_ingest.rb
 - lib/legion/extensions/microsoft_teams/actors/auth_validator.rb
 - lib/legion/extensions/microsoft_teams/actors/cache_bulk_ingest.rb