lex-service_now 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9850b5ae25b0769c3e26b07fac9cbfe6fb6913e718e0eaba29c2a62e42bdc155
+  data.tar.gz: 72b828b004be9fe534c51a677c011a6cbe8d6470f91e7b25912d42b1ee1eb956
+SHA512:
+  metadata.gz: 6d728a8a52d1178d62eaa70b3d1c90b41a22fff61e9a8dc6916369eeb508e523f16b09c7e12262c8d6dec3c13ad62892ccfbffe6a8dc33ceca56379b26cff5fd
+  data.tar.gz: ae69b9ad088f9f5ed8fb5420cb6dea76eb6c083152af6800af83d74a34c8f32f1d093da9a3ede7b8b6f95ece399f65f8a3c32d3c0e2e380afbf12c59acc37f1b

data/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Auto-generated from team-config.yml
+# Team: extensions
+#
+# To apply: scripts/apply-codeowners.sh lex-service_now
+
+* @LegionIO/maintainers
+* @LegionIO/extensions

data/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"

data/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  lint:
+    uses: LegionIO/.github/.github/workflows/lint-patterns.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
+  release:
+    needs: [ci, lint]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,56 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/ParameterLists:
+  Max: 8
+
+Naming/MethodParameterName:
+  MinNameLength: 2
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [0.1.0] - 2026-04-22
+
+### Added
+- Initial release
+- Change Management API (14 methods)
+- CMDB Instance API (7 methods)
+- CMDB Meta API (2 methods)
+- Knowledge API (5 methods)
+- Service Catalog API (11 methods)
+- Account API (4 methods)
+- LLM skill triggers for Incident, ChangeRequest, CmdbQuery, Knowledge, ServiceCatalog

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'bundler', '>= 2'
+gem 'rake'
+gem 'rspec'
+gem 'rspec_junit_formatter'
+gem 'rubocop'
+gem 'rubocop-legion'
+gem 'rubocop-rspec'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Esity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lex-service_now.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/service_now/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-service_now'
+  spec.version       = Legion::Extensions::ServiceNow::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX::ServiceNow'
+  spec.description   = 'Connects Legion to ServiceNow via Change Management, CMDB, Knowledge, Service Catalog, and Account REST APIs'
+  spec.homepage      = 'https://github.com/LegionIO/lex-service_now'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']          = spec.homepage
+  spec.metadata['source_code_uri']       = 'https://github.com/LegionIO/lex-service_now'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-service_now/blob/main/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday',            '>= 2.0'
+  spec.add_dependency 'legion-cache',       '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',       '>= 1.4.9'
+  spec.add_dependency 'legion-data',        '>= 1.4.17'
+  spec.add_dependency 'legion-json',        '>= 1.2.1'
+  spec.add_dependency 'legion-logging',     '>= 1.3.2'
+  spec.add_dependency 'legion-settings',    '>= 1.3.14'
+  spec.add_dependency 'legion-transport',   '>= 1.3.9'
+end

data/lib/legion/extensions/service_now/account/runners/account.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Account
+        module Runners
+          module Account
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_accounts(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/account', params)
+              { accounts: resp.body['result'] }
+            end
+
+            def get_account(sys_id:, **)
+              resp = connection(**).get("/api/now/account/#{sys_id}")
+              { account: resp.body['result'] }
+            end
+
+            def create_account(name:, phone: nil, email: nil, **)
+              body = { name: name }
+              body[:phone] = phone if phone
+              body[:email] = email if email
+              resp = connection(**).post('/api/now/account', body)
+              { account: resp.body['result'] }
+            end
+
+            def update_account(sys_id:, name: nil, phone: nil, email: nil, **)
+              body = {}
+              body[:name]  = name if name
+              body[:phone] = phone if phone
+              body[:email] = email if email
+              resp = connection(**).patch("/api/now/account/#{sys_id}", body)
+              { account: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/change/runners/change.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Change
+        module Runners
+          module Change
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_changes(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/sn_chg_rest/change', params)
+              { changes: resp.body['result'] }
+            end
+
+            def create_normal(short_description:, description: nil, assignment_group: nil,
+                              start_date: nil, end_date: nil, **)
+              body = { short_description: short_description }
+              body[:description]      = description if description
+              body[:assignment_group] = assignment_group if assignment_group
+              body[:start_date]       = start_date if start_date
+              body[:end_date]         = end_date if end_date
+              resp = connection(**).post('/api/sn_chg_rest/change/normal', body)
+              { change: resp.body['result'] }
+            end
+
+            def create_emergency(short_description:, description: nil, assignment_group: nil, **)
+              body = { short_description: short_description }
+              body[:description]      = description if description
+              body[:assignment_group] = assignment_group if assignment_group
+              resp = connection(**).post('/api/sn_chg_rest/change/emergency', body)
+              { change: resp.body['result'] }
+            end
+
+            def create_standard(short_description:, description: nil, assignment_group: nil, **)
+              body = { short_description: short_description }
+              body[:description]      = description if description
+              body[:assignment_group] = assignment_group if assignment_group
+              resp = connection(**).post('/api/sn_chg_rest/change/standard', body)
+              { change: resp.body['result'] }
+            end
+
+            def get_change(id:, **)
+              resp = connection(**).get("/api/sn_chg_rest/change/#{id}")
+              { change: resp.body['result'] }
+            end
+
+            def update_change(id:, short_description: nil, description: nil, state: nil,
+                              assignment_group: nil, start_date: nil, end_date: nil, **)
+              body = {}
+              body[:short_description] = short_description if short_description
+              body[:description]       = description if description
+              body[:state]             = state if state
+              body[:assignment_group]  = assignment_group if assignment_group
+              body[:start_date]        = start_date if start_date
+              body[:end_date]          = end_date if end_date
+              resp = connection(**).patch("/api/sn_chg_rest/change/#{id}", body)
+              { change: resp.body['result'] }
+            end
+
+            def delete_change(id:, **)
+              resp = connection(**).delete("/api/sn_chg_rest/change/#{id}")
+              { deleted: resp.status == 204, id: id }
+            end
+
+            def list_tasks(id:, **)
+              resp = connection(**).get("/api/sn_chg_rest/change/#{id}/task")
+              { tasks: resp.body['result'] }
+            end
+
+            def create_task(id:, short_description:, **)
+              body = { short_description: short_description }
+              resp = connection(**).post("/api/sn_chg_rest/change/#{id}/task", body)
+              { task: resp.body['result'] }
+            end
+
+            def update_task(id:, task_id:, short_description: nil, state: nil, assigned_to: nil, **)
+              body = {}
+              body[:short_description] = short_description if short_description
+              body[:state]             = state if state
+              body[:assigned_to]       = assigned_to if assigned_to
+              resp = connection(**).patch("/api/sn_chg_rest/change/#{id}/task/#{task_id}", body)
+              { task: resp.body['result'] }
+            end
+
+            def delete_task(id:, task_id:, **)
+              resp = connection(**).delete("/api/sn_chg_rest/change/#{id}/task/#{task_id}")
+              { deleted: resp.status == 204, task_id: task_id }
+            end
+
+            def get_conflicts(id:, **)
+              resp = connection(**).get("/api/sn_chg_rest/change/#{id}/conflict")
+              { conflicts: resp.body['result'] }
+            end
+
+            def calculate_conflicts(id:, **)
+              resp = connection(**).post("/api/sn_chg_rest/change/#{id}/conflict", {})
+              { conflicts: resp.body['result'] }
+            end
+
+            def get_approvals(id:, **)
+              resp = connection(**).get("/api/sn_chg_rest/change/#{id}/approvals")
+              { approvals: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      class Client
+        include Helpers::Client
+        include Change::Runners::Change
+        include Cmdb::Instance::Runners::Instance
+        include Cmdb::Meta::Runners::Meta
+        include Knowledge::Runners::Knowledge
+        include ServiceCatalog::Runners::ServiceCatalog
+        include Account::Runners::Account
+
+        attr_reader :opts
+
+        def initialize(url: nil, client_id: nil, client_secret: nil,
+                       token: nil, username: nil, password: nil, **extra)
+          @opts = {
+            url:           url,
+            client_id:     client_id,
+            client_secret: client_secret,
+            token:         token,
+            username:      username,
+            password:      password,
+            **extra
+          }.compact
+        end
+
+        def connection(**override)
+          super(**@opts, **override)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/cmdb/instance/runners/instance.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Cmdb
+        module Instance
+          module Runners
+            module Instance
+              include Legion::Extensions::ServiceNow::Helpers::Client
+
+              def list_cis(class_name:, sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+                params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+                params[:sysparm_query] = sysparm_query if sysparm_query
+                resp = connection(**).get("/api/now/cmdb/instance/#{class_name}", params)
+                { records: resp.body['result']['records'] }
+              end
+
+              def create_ci(class_name:, name: nil, ip_address: nil, os: nil, **)
+                body = {}
+                body[:name]       = name if name
+                body[:ip_address] = ip_address if ip_address
+                body[:os]         = os if os
+                resp = connection(**).post("/api/now/cmdb/instance/#{class_name}", body)
+                { record: resp.body['result']['record'] }
+              end
+
+              def get_ci(class_name:, sys_id:, **)
+                resp = connection(**).get("/api/now/cmdb/instance/#{class_name}/#{sys_id}")
+                { record: resp.body['result']['record'] }
+              end
+
+              def update_ci(class_name:, sys_id:, name: nil, ip_address: nil, os: nil, location: nil, **)
+                body = {}
+                body[:name]       = name if name
+                body[:ip_address] = ip_address if ip_address
+                body[:os]         = os if os
+                body[:location]   = location if location
+                resp = connection(**).patch("/api/now/cmdb/instance/#{class_name}/#{sys_id}", body)
+                { record: resp.body['result']['record'] }
+              end
+
+              def delete_ci(class_name:, sys_id:, **)
+                resp = connection(**).delete("/api/now/cmdb/instance/#{class_name}/#{sys_id}")
+                { deleted: resp.status == 204, sys_id: sys_id }
+              end
+
+              def get_relationships(class_name:, sys_id:, **)
+                resp = connection(**).get("/api/now/cmdb/instance/#{class_name}/#{sys_id}/relationships")
+                { relationships: resp.body['result'] }
+              end
+
+              def create_relationship(class_name:, sys_id:, target_id:, relationship_type:, **)
+                body = { target_id: target_id, relationship_type: relationship_type }
+                resp = connection(**).post("/api/now/cmdb/instance/#{class_name}/#{sys_id}/relationships", body)
+                { relationship: resp.body['result'] }
+              end
+
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/cmdb/meta/runners/meta.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Cmdb
+        module Meta
+          module Runners
+            module Meta
+              include Legion::Extensions::ServiceNow::Helpers::Client
+
+              def get_hierarchy(**)
+                resp = connection(**).get('/api/now/doc/meta/hierarchy')
+                { hierarchy: resp.body['result'] }
+              end
+
+              def get_class_meta(class_name:, **)
+                resp = connection(**).get("/api/now/doc/meta/#{class_name}")
+                { meta: resp.body['result'] }
+              end
+
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/helpers/client.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Helpers
+        module Client
+          def connection(url: nil, client_id: nil, client_secret: nil,
+                         token: nil, username: nil, password: nil, **)
+            base_url = url || Legion::Settings[:service_now][:url]
+            Faraday.new(url: base_url) do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              if client_id && client_secret
+                conn.headers['Authorization'] = "Bearer #{fetch_oauth2_token(base_url, client_id, client_secret)}"
+              elsif token
+                conn.headers['Authorization'] = "Bearer #{token}"
+              elsif username && password
+                conn.request :authorization, :basic, username, password
+              end
+              conn.adapter Faraday.default_adapter
+            end
+          end
+
+          def fetch_oauth2_token(base_url, client_id, client_secret)
+            @fetch_oauth2_token ||= begin
+              resp = Faraday.new(url: base_url) do |conn|
+                conn.request :url_encoded
+                conn.response :json, content_type: /\bjson$/
+                conn.adapter Faraday.default_adapter
+              end.post('/oauth_token.do', {
+                         grant_type:    'client_credentials',
+                         client_id:     client_id,
+                         client_secret: client_secret
+                       })
+              resp.body['access_token']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/knowledge/runners/knowledge.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Knowledge
+        module Runners
+          module Knowledge
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_articles(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/sn_km_api/knowledge', params)
+              { articles: resp.body['result'] }
+            end
+
+            def get_article(sys_id:, **)
+              resp = connection(**).get("/api/sn_km_api/knowledge/#{sys_id}")
+              { article: resp.body['result'] }
+            end
+
+            def create_article(short_description:, text: nil, knowledge_base: nil, **)
+              body = { short_description: short_description }
+              body[:text]           = text if text
+              body[:knowledge_base] = knowledge_base if knowledge_base
+              resp = connection(**).post('/api/sn_km_api/knowledge', body)
+              { article: resp.body['result'] }
+            end
+
+            def update_article(sys_id:, short_description: nil, text: nil, **)
+              body = {}
+              body[:short_description] = short_description if short_description
+              body[:text]              = text if text
+              resp = connection(**).patch("/api/sn_km_api/knowledge/#{sys_id}", body)
+              { article: resp.body['result'] }
+            end
+
+            def delete_article(sys_id:, **)
+              resp = connection(**).delete("/api/sn_km_api/knowledge/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/service_catalog/runners/service_catalog.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module ServiceCatalog
+        module Runners
+          module ServiceCatalog
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_catalogs(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/sn_sc/servicecatalog/catalogs', params)
+              { catalogs: resp.body['result'] }
+            end
+
+            def get_catalog(sys_id:, **)
+              resp = connection(**).get("/api/sn_sc/servicecatalog/catalogs/#{sys_id}")
+              { catalog: resp.body['result'] }
+            end
+
+            def get_category(sys_id:, **)
+              resp = connection(**).get("/api/sn_sc/servicecatalog/categories/#{sys_id}")
+              { category: resp.body['result'] }
+            end
+
+            def list_items(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil,
+                           catalog_id: nil, category_id: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              params[:catalog_id]    = catalog_id if catalog_id
+              params[:category_id]   = category_id if category_id
+              resp = connection(**).get('/api/sn_sc/servicecatalog/items', params)
+              { items: resp.body['result'] }
+            end
+
+            def get_item(sys_id:, **)
+              resp = connection(**).get("/api/sn_sc/servicecatalog/items/#{sys_id}")
+              { item: resp.body['result'] }
+            end
+
+            def get_item_variables(sys_id:, **)
+              resp = connection(**).get("/api/sn_sc/servicecatalog/items/#{sys_id}/variables")
+              { variables: resp.body['result'] }
+            end
+
+            def order_now(sys_id:, quantity: 1, variables: nil, **)
+              body = { quantity: quantity }
+              body[:variables] = variables if variables
+              resp = connection(**).post("/api/sn_sc/servicecatalog/items/#{sys_id}/order_now", body)
+              { request: resp.body['result'] }
+            end
+
+            def add_to_cart(sys_id:, quantity: 1, variables: nil, **)
+              body = { quantity: quantity }
+              body[:variables] = variables if variables
+              resp = connection(**).post("/api/sn_sc/servicecatalog/items/#{sys_id}/add_to_cart", body)
+              { cart: resp.body['result'] }
+            end
+
+            def get_cart(**)
+              resp = connection(**).get('/api/sn_sc/servicecatalog/cart')
+              { cart: resp.body['result'] }
+            end
+
+            def checkout_cart(**)
+              resp = connection(**).post('/api/sn_sc/servicecatalog/cart/checkout', {})
+              { order: resp.body['result'] }
+            end
+
+            def delete_cart(cart_id:, **)
+              resp = connection(**).delete("/api/sn_sc/servicecatalog/cart/#{cart_id}")
+              { deleted: resp.status == 204, cart_id: cart_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/skills/change_request.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Skills
+        class ChangeRequest < Legion::LLM::Skills::Base
+          skill_name 'servicenow:change_request'
+          namespace  'servicenow'
+          description 'Guides through ServiceNow change request creation and CAB approval workflow'
+          trigger :on_demand
+          trigger_words 'CHG', 'RFC', 'change request', 'CAB', 'change advisory board', 'change management'
+
+          steps :gather_requirements,
+                :risk_assessment,
+                :draft_and_review,
+                :submit_for_approval,
+                :complete
+
+          def gather_requirements(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Gathering change requirements: scope, timeline, and affected systems.',
+              metadata: { step: 'gather_requirements' }
+            )
+          end
+
+          def risk_assessment(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Assessing risk: impact, likelihood, and rollback plan.',
+              metadata: { step: 'risk_assessment' }
+            )
+          end
+
+          def draft_and_review(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Drafting change request. Please review the details.',
+              metadata: { step: 'draft_and_review' },
+              gate:     :confirm
+            )
+          end
+
+          def submit_for_approval(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Submitting change request for CAB approval.',
+              metadata: { step: 'submit_for_approval' }
+            )
+          end
+
+          def complete(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Change request submitted successfully.',
+              metadata: { step: 'complete' }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/skills/cmdb_query.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Skills
+        class CmdbQuery < Legion::LLM::Skills::Base
+          skill_name 'servicenow:cmdb_query'
+          namespace  'servicenow'
+          description 'Guides through CMDB configuration item lookup and relationship exploration'
+          trigger :on_demand
+          trigger_words 'CMDB', 'CI', 'configuration item', 'asset', 'cmdb_ci', 'server lookup'
+
+          steps :clarify_query,
+                :scope_search,
+                :present_results,
+                :complete
+
+          def clarify_query(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Clarifying CMDB query: what CI class and attributes are you looking for?',
+              metadata: { step: 'clarify_query' },
+              gate:     :confirm
+            )
+          end
+
+          def scope_search(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Scoping CMDB search by class, name, and environment.',
+              metadata: { step: 'scope_search' }
+            )
+          end
+
+          def present_results(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Presenting CMDB query results with relationships.',
+              metadata: { step: 'present_results' }
+            )
+          end
+
+          def complete(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'CMDB query complete.',
+              metadata: { step: 'complete' }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/skills/incident.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Skills
+        class Incident < Legion::LLM::Skills::Base
+          skill_name 'servicenow:incident'
+          namespace  'servicenow'
+          description 'Guides through ServiceNow incident response workflow'
+          trigger :on_demand
+          trigger_words 'incident', 'INC', 'outage', 'p1', 'sev1', 'production down', 'service down'
+
+          steps :gather_context,
+                :assess_severity,
+                :determine_action,
+                :confirm_with_user,
+                :complete
+
+          def gather_context(context: {})
+            Legion::LLM::Skills::StepResult.new(
+              inject:   "Gathering incident context from ServiceNow. Project: #{detect_project(context)}",
+              metadata: { step: 'gather_context' }
+            )
+          end
+
+          def assess_severity(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Assessing incident severity based on impact and urgency.',
+              metadata: { step: 'assess_severity' }
+            )
+          end
+
+          def determine_action(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Determining recommended action: escalate, assign, or resolve.',
+              metadata: { step: 'determine_action' },
+              gate:     :confirm
+            )
+          end
+
+          def confirm_with_user(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Awaiting user confirmation before proceeding.',
+              metadata: { step: 'confirm_with_user' }
+            )
+          end
+
+          def complete(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Incident workflow complete.',
+              metadata: { step: 'complete' }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/skills/knowledge.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Skills
+        class Knowledge < Legion::LLM::Skills::Base
+          skill_name 'servicenow:knowledge'
+          namespace  'servicenow'
+          description 'Guides through ServiceNow knowledge base article search and retrieval'
+          trigger :on_demand
+          trigger_words 'KB', 'knowledge base', 'knowledge article', 'how to', 'documentation search'
+
+          steps :gather_search_terms,
+                :search_articles,
+                :present_results,
+                :complete
+
+          def gather_search_terms(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'What are you looking for in the knowledge base?',
+              metadata: { step: 'gather_search_terms' },
+              gate:     :confirm
+            )
+          end
+
+          def search_articles(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Searching ServiceNow knowledge base.',
+              metadata: { step: 'search_articles' }
+            )
+          end
+
+          def present_results(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Presenting matching knowledge articles.',
+              metadata: { step: 'present_results' }
+            )
+          end
+
+          def complete(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Knowledge search complete.',
+              metadata: { step: 'complete' }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/skills/service_catalog.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Skills
+        class ServiceCatalog < Legion::LLM::Skills::Base
+          skill_name 'servicenow:service_catalog'
+          namespace  'servicenow'
+          description 'Guides through ServiceNow service catalog browsing and request ordering'
+          trigger :on_demand
+          trigger_words 'catalog', 'service request', 'order', 'request item', 'service catalog'
+
+          steps :browse_catalog,
+                :select_item,
+                :configure_request,
+                :submit_order,
+                :complete
+
+          def browse_catalog(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Browsing ServiceNow service catalog.',
+              metadata: { step: 'browse_catalog' }
+            )
+          end
+
+          def select_item(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Which catalog item would you like to request?',
+              metadata: { step: 'select_item' },
+              gate:     :confirm
+            )
+          end
+
+          def configure_request(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Configuring request variables and quantity.',
+              metadata: { step: 'configure_request' },
+              gate:     :confirm
+            )
+          end
+
+          def submit_order(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Submitting service catalog order.',
+              metadata: { step: 'submit_order' }
+            )
+          end
+
+          def complete(context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            Legion::LLM::Skills::StepResult.new(
+              inject:   'Service catalog request submitted.',
+              metadata: { step: 'complete' }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/service_now.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/service_now/version'
+require 'legion/extensions/service_now/helpers/client'
+
+require 'legion/extensions/service_now/change/runners/change'
+require 'legion/extensions/service_now/cmdb/instance/runners/instance'
+require 'legion/extensions/service_now/cmdb/meta/runners/meta'
+require 'legion/extensions/service_now/knowledge/runners/knowledge'
+require 'legion/extensions/service_now/service_catalog/runners/service_catalog'
+require 'legion/extensions/service_now/account/runners/account'
+
+require 'legion/extensions/service_now/client'
+
+if defined?(Legion::LLM)
+  require 'legion/extensions/service_now/skills/incident'
+  require 'legion/extensions/service_now/skills/change_request'
+  require 'legion/extensions/service_now/skills/cmdb_query'
+  require 'legion/extensions/service_now/skills/knowledge'
+  require 'legion/extensions/service_now/skills/service_catalog'
+end
+
+module Legion
+  module Extensions
+    module ServiceNow
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: lex-service_now
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: Connects Legion to ServiceNow via Change Management, CMDB, Knowledge,
+  Service Catalog, and Account REST APIs
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- Rakefile
+- lex-service_now.gemspec
+- lib/legion/extensions/service_now.rb
+- lib/legion/extensions/service_now/account/runners/account.rb
+- lib/legion/extensions/service_now/change/runners/change.rb
+- lib/legion/extensions/service_now/client.rb
+- lib/legion/extensions/service_now/cmdb/instance/runners/instance.rb
+- lib/legion/extensions/service_now/cmdb/meta/runners/meta.rb
+- lib/legion/extensions/service_now/helpers/client.rb
+- lib/legion/extensions/service_now/knowledge/runners/knowledge.rb
+- lib/legion/extensions/service_now/service_catalog/runners/service_catalog.rb
+- lib/legion/extensions/service_now/skills/change_request.rb
+- lib/legion/extensions/service_now/skills/cmdb_query.rb
+- lib/legion/extensions/service_now/skills/incident.rb
+- lib/legion/extensions/service_now/skills/knowledge.rb
+- lib/legion/extensions/service_now/skills/service_catalog.rb
+- lib/legion/extensions/service_now/version.rb
+homepage: https://github.com/LegionIO/lex-service_now
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-service_now
+  source_code_uri: https://github.com/LegionIO/lex-service_now
+  changelog_uri: https://github.com/LegionIO/lex-service_now/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX::ServiceNow
+test_files: []