superkick 0.1.0

data/lib/superkick/integrations/github/repository_source.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "octokit"
+
+module Superkick
+  module Integrations
+    module GitHub
+      # OrganizationRepositorySource — discovers repositories from a GitHub
+      # organization or user account using the GitHub API.
+      #
+      # All metadata (descriptions, topics, clone URLs, READMEs) is fetched via the
+      # GitHub API using the provided token — no SSH keys needed.
+      #
+      # Config:
+      #   type: github_organization
+      #   organization: my-org              # required — GitHub organization or user name
+      #   token: ghp_...                    # optional — falls back to GITHUB_TOKEN env var
+      #   context_documents: [readme, ...]   # optional — documents to fetch (default [])
+      #   include_archived: false           # optional — include archived repositories (default false)
+      #   include_forks: false              # optional — include forked repositories (default false)
+      #   topic_filter: [backend, api]      # optional — only repositories with ALL listed topics
+      #   exclude: [old-repo, deprecated]   # optional — repository names to exclude
+      #   visibility: public               # optional — public, private, or all (default all)
+      #
+      # Example YAML:
+      #   repositories:
+      #     type: github_organization
+      #     organization: my-company
+      #     token: <%= env("GITHUB_TOKEN") %>
+      #     topic_filter:
+      #       - production
+      #     exclude:
+      #       - legacy-app
+      class OrganizationRepositorySource < Superkick::RepositorySource
+        def self.type = :github_organization
+
+        def self.setup_label = "GitHub Organization"
+
+        def self.setup_config
+          <<~YAML
+            company:
+              type: github_organization
+              organization: my-company
+              token: <%= env("GITHUB_TOKEN") %>
+              # include_archived: false          # include archived repos (default false)
+              # include_forks: false             # include forked repos (default false)
+              # topic_filter:                    # only repos with ALL listed topics
+              #   - production
+              # exclude:                         # repository names to exclude
+              #   - legacy-app
+              # visibility: all                  # public, private, or all (default)
+          YAML
+        end
+
+        # @param config [Hash] source configuration
+        # @param client [Octokit::Client, nil] optional pre-built client (used in tests)
+        def initialize(config = {}, client: nil)
+          @organization = config[:organization]
+          @token = config[:token] || ENV["GITHUB_TOKEN"]
+          @include_archived = config.fetch(:include_archived, false)
+          @include_forks = config.fetch(:include_forks, false)
+          @topic_filter = Array(config[:topic_filter]).map(&:to_s)
+          @exclude = Array(config[:exclude]).map(&:to_s).to_set
+          @visibility = config.fetch(:visibility, "all").to_s
+          @client = client
+          @context_document_patterns = merge_context_document_patterns(config[:context_documents])
+
+          @repositories = fetch_all_repositories.freeze
+        end
+
+        attr_reader :repositories
+
+        private
+
+        def fetch_all_repositories
+          return {} unless @organization
+
+          api_client = @client || build_client
+          github_repositories = fetch_from_api(api_client)
+          github_repositories = apply_filters(github_repositories)
+
+          github_repositories.each_with_object({}) do |gh_repository, h|
+            name = gh_repository.name.to_sym
+            topics = fetch_topics(api_client, gh_repository.full_name)
+
+            # Apply topic filter — skip repositories that don't have all required topics
+            next if @topic_filter.any? && !@topic_filter.all? { topics.include?(it) }
+
+            h[name] = Repository.new(
+              name:,
+              url: gh_repository.clone_url,
+              version_control: :git
+            )
+
+            fetch_context_documents(api_client, gh_repository.full_name, h[name])
+          end
+        rescue Octokit::Unauthorized => e
+          Superkick.logger.error("github_organization_registry") { "GitHub auth failed: #{e.message}" }
+          {}
+        rescue Octokit::TooManyRequests => e
+          Superkick.logger.error("github_organization_registry") { "GitHub rate limited: #{e.message}" }
+          {}
+        rescue Faraday::Error => e
+          Superkick.logger.error("github_organization_registry") { "GitHub API error: #{e.message}" }
+          {}
+        end
+
+        def fetch_from_api(api_client)
+          options = {per_page: 100}
+          options[:type] = @visibility unless @visibility == "all"
+
+          api_client.auto_paginate = true
+
+          # Try organization repositories first, fall back to user repositories
+          begin
+            api_client.org_repos(@organization, **options)
+          rescue Octokit::NotFound
+            api_client.repos(@organization, **options)
+          end
+        end
+
+        def apply_filters(github_repositories)
+          github_repositories = github_repositories.reject(&:archived) unless @include_archived
+          github_repositories = github_repositories.reject(&:fork) unless @include_forks
+          github_repositories.reject { @exclude.include?(it.name) }
+        end
+
+        def fetch_topics(api_client, full_name)
+          repository_data = api_client.repo(full_name)
+          Array(repository_data.topics).map(&:to_s)
+        rescue Octokit::Error
+          []
+        end
+
+        def fetch_context_documents(api_client, full_name, repository)
+          return if @context_document_patterns.empty?
+
+          @context_document_patterns.each do |name, pattern|
+            content = if name == :readme
+              # Use the dedicated readme endpoint for the :readme document
+              fetch_file_via_readme(api_client, full_name)
+            else
+              fetch_file_by_pattern(api_client, full_name, pattern)
+            end
+            repository.set_context_document(name, content) if content
+          end
+        end
+
+        def fetch_file_via_readme(api_client, full_name)
+          readme = api_client.readme(full_name, accept: "application/vnd.github.raw+json")
+          readme.is_a?(String) ? readme : readme.content
+        rescue Octokit::NotFound
+          nil
+        rescue Octokit::Error => e
+          Superkick.logger.debug("github_organization_registry") { "Could not fetch README for #{full_name}: #{e.message}" }
+          nil
+        end
+
+        def fetch_file_by_pattern(api_client, full_name, pattern)
+          # For simple non-glob patterns, fetch directly
+          unless pattern.include?("*") || pattern.include?("?")
+            return fetch_single_file(api_client, full_name, pattern)
+          end
+
+          # For glob patterns, list the repo tree and find the first match
+          tree = api_client.tree(full_name, "HEAD", recursive: pattern.include?("/"))
+          matching = tree.tree.select { |item| item.type == "blob" && File.fnmatch(pattern, item.path) }
+          return nil if matching.empty?
+
+          fetch_single_file(api_client, full_name, matching.first.path)
+        rescue Octokit::Error => e
+          Superkick.logger.debug("github_organization_registry") { "Could not fetch #{pattern} for #{full_name}: #{e.message}" }
+          nil
+        end
+
+        def fetch_single_file(api_client, full_name, path)
+          response = api_client.contents(full_name, path:, accept: "application/vnd.github.raw+json")
+          response.is_a?(String) ? response : nil
+        rescue Octokit::NotFound
+          nil
+        rescue Octokit::Error => e
+          Superkick.logger.debug("github_organization_registry") { "Could not fetch #{path} for #{full_name}: #{e.message}" }
+          nil
+        end
+
+        def merge_context_document_patterns(per_source_config)
+          global = Superkick.config.resolved_context_document_patterns
+          local = resolve_context_document_entries(per_source_config)
+          global.merge(local)
+        end
+
+        def resolve_context_document_entries(config)
+          return {} unless config.is_a?(Array) && config.any?
+
+          config.each_with_object({}) do |entry, h|
+            if entry.is_a?(Hash) && entry[:name] && entry[:pattern]
+              h[entry[:name].to_sym] = entry[:pattern].to_s
+            elsif entry.is_a?(String) || entry.is_a?(Symbol)
+              name = entry.to_sym
+              pattern = Repository::CONTEXT_DOCUMENT_PATTERNS[name]
+              h[name] = pattern if pattern
+            end
+          end
+        end
+
+        def build_client
+          Octokit::Client.new(
+            access_token: @token,
+            middleware: faraday_stack
+          )
+        end
+
+        def faraday_stack
+          Faraday::RackBuilder.new do |builder|
+            builder.request :retry,
+              max: 3,
+              interval: 0.5,
+              backoff_factor: 2,
+              exceptions: Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed]
+            builder.adapter Faraday.default_adapter
+          end
+        end
+      end
+    end
+  end
+
+  RepositorySource.register(Integrations::GitHub::OrganizationRepositorySource)
+end

data/lib/superkick/integrations/github/templates/check_failed.liquid

@@ -0,0 +1,10 @@
+SUPERKICK [{{ "now" | time }}]: GitHub checks FAILED on {{ branch }} ({{ sha | short_sha }})
+Repository: {{ repo }}
+Commit: {{ commit.message }} by {{ commit.author }}
+{% for check in failed_checks -%}
+- {{ check.name }} ({{ check.app }}): {{ check.conclusion }}{% if check.details_url %} — {{ check.details_url }}{% endif %}
+{% endfor -%}
+{{ failed_checks.size }} of {{ total_checks }} checks failed.
+
+Please investigate the failures, fix the underlying issues, write or update
+tests as needed, and push a fix. Check the details URLs above for full logs.

data/lib/superkick/integrations/github/templates/ci_failure.liquid

@@ -0,0 +1,5 @@
+SUPERKICK [{{ "now" | time }}]: CI checks FAILED on {{ branch }} ({{ sha | short_sha }})
+{% if failed_checks.size > 0 -%}
+Failed: {{ failed_checks | join: ", " }}
+{% endif -%}
+Please review the CI output and fix the failures before continuing.

data/lib/superkick/integrations/github/templates/ci_success.liquid

@@ -0,0 +1 @@
+SUPERKICK [{{ "now" | time }}]: All {{ check_count }} CI checks passed on {{ branch }} ({{ sha | short_sha }}).

data/lib/superkick/integrations/github/templates/issue_opened.liquid

@@ -0,0 +1,20 @@
+SUPERKICK [{{ "now" | time }}]: GitHub issue assigned — #{{ issue.number }} {{ issue.title }}
+URL: {{ issue.url }}
+Author: @{{ issue.author }}
+{% if issue.labels.size > 0 -%}
+Labels: {{ issue.labels | join: ", " }}
+{% endif -%}
+{% if issue.assignees.size > 0 -%}
+Assignees: {% for a in issue.assignees %}@{{ a }}{% unless forloop.last %}, {% endunless %}{% endfor %}
+{% endif -%}
+{% if issue.milestone -%}
+Milestone: {{ issue.milestone }}
+{% endif -%}
+
+## Description
+
+{% if issue.body == "" %}(no description){% else %}{{ issue.body }}{% endif %}
+
+Please read the issue description carefully. Implement the requested changes,
+write tests, and commit your work. If anything is unclear, check the issue
+comments for additional context.

data/lib/superkick/integrations/github/templates/pr_comment.liquid

@@ -0,0 +1,2 @@
+SUPERKICK [{{ "now" | time }}]: New PR comment on {{ pull_request.ref }} from {{ comment.author }}:
+"{{ comment.body | truncate: 200 }}"

data/lib/superkick/integrations/github/templates/pr_review.liquid

@@ -0,0 +1,4 @@
+SUPERKICK [{{ "now" | time }}]: PR review {{ review.state }} on {{ pull_request.ref }} by {{ review.author }}.
+{% unless review.body == "" -%}
+"{{ review.body | truncate: 200 }}"
+{% endunless -%}

data/lib/superkick/integrations/github.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "github/drops"
+require_relative "github/monitor"
+require_relative "github/probe"
+require_relative "github/goal"
+require_relative "github/issue_goal"
+require_relative "github/issue_spawner"
+require_relative "github/check_failed_spawner"
+require_relative "github/repository_source"
+
+module Superkick
+  Monitor.register(Integrations::GitHub::Monitor)
+  Spawner.register(Integrations::GitHub::IssueSpawner)
+  Spawner.register(Integrations::GitHub::CheckFailedSpawner)
+end

data/lib/superkick/integrations/honeybadger/README.md

@@ -0,0 +1,97 @@
+# Honeybadger Integration
+
+Provides: **notifier**, **spawner**
+
+## Notifier (`:honeybadger`)
+
+Sends structured events to Honeybadger Insights via the Events API. See the
+[Notifications section](../../../../README.md#notifications) in the main README
+for notifier configuration.
+
+## Spawner (`:honeybadger`)
+
+Watches Honeybadger for unresolved faults and spawns AI coding agents to fix
+them. Polls the Honeybadger Faults API for faults matching configurable filters
+(environment, fault class, minimum occurrence count).
+
+Faults are tracked by ID to prevent re-dispatching. Faults that fail
+client-side filters (e.g. below `minimum_occurrences`) are retried on
+subsequent ticks so they fire once the threshold is crossed.
+
+### Configuration
+
+```yaml
+spawners:
+  honeybadger:
+    type: honeybadger
+    project_id: "12345"
+    token: <%= env("HONEYBADGER_TOKEN") %>
+    driver: claude_code
+    environment: production
+    minimum_occurrences: 5
+    fault_classes:
+      include:
+        - NoMethodError
+        - RuntimeError
+      exclude:
+        - Net::ReadTimeout
+```
+
+| Key | Required | Default | Description |
+|-----|----------|---------|-------------|
+| `project_id` | yes | — | Honeybadger project ID |
+| `token` | no | `$HONEYBADGER_TOKEN` | Honeybadger API auth token |
+| `environment` | no | `"production"` | Environment name |
+| `minimum_occurrences` | no | `1` | Minimum occurrence count before dispatching |
+| `fault_classes` | no | — | Fault class filter (array or include/exclude hash) |
+
+### Fault class filter format
+
+The `fault_classes` key accepts two formats:
+
+- **Array** — treated as an include list: `["NoMethodError", "TypeError"]`
+- **Hash** — explicit include/exclude: `{ include: ["NoMethodError"], exclude: ["Net::ReadTimeout"] }`
+
+Include filters are applied server-side (via the Honeybadger API search query).
+Exclude filters are applied client-side after fetching.
+
+### Agent ID format
+
+```
+honeybadger-fault-{fault_id}
+```
+
+Where `fault_id` is the Honeybadger fault ID. Dedup is handled by
+`AgentStore` — if an agent with the same ID already exists, the spawn is
+skipped.
+
+### Events
+
+#### `error_opened`
+
+Dispatched when a new unresolved fault is found that passes all filters.
+
+Template variables:
+
+| Variable | Description |
+|----------|-------------|
+| `fault_id` | Honeybadger fault ID |
+| `error_class` | Exception class name (e.g. `NoMethodError`) |
+| `message` | Error message string |
+| `environment` | Environment name |
+| `events` | Total occurrence count |
+| `users` | Number of impacted users |
+| `first_seen` | Timestamp of first occurrence |
+| `last_seen` | Timestamp of most recent occurrence |
+| `component` | Controller/component name |
+| `action` | Action name |
+| `assignee` | Assigned user (hash or nil) |
+| `url` | Honeybadger dashboard URL for this fault |
+| `project_id` | Honeybadger project ID |
+
+### Error handling
+
+- **401/403** — raises `FatalError`, stops the spawner (authentication failure)
+- **429** — raises `RateLimited`, backs off per the standard poller backoff
+- **404** — logged as warning, skipped (resource not found)
+- Other HTTP errors — logged as warning, skipped

data/lib/superkick/integrations/honeybadger/notification_templates/default.liquid

@@ -0,0 +1,8 @@
+{% event_message %}{{ message }}{% endevent_message %}
+{% severity %}{{ event_type | honeybadger_severity }}{% endseverity %}
+{% if monitor %}{% payload_field key: "monitor_type" %}{{ monitor.type }}{% endpayload_field %}
+{% payload_field key: "monitor_name" %}{{ monitor.name }}{% endpayload_field %}{% endif %}
+{% if team %}{% payload_field key: "team_id" %}{{ team.id }}{% endpayload_field %}{% endif %}
+{% if agent.role %}{% payload_field key: "team_role" %}{{ agent.role }}{% endpayload_field %}{% endif %}
+{% if spawner %}{% payload_field key: "spawner_name" %}{{ spawner.name }}{% endpayload_field %}{% endif %}
+{% if agent.cost_usd %}{% payload_field key: "cost_usd" %}{{ agent.cost_usd }}{% endpayload_field %}{% endif %}

data/lib/superkick/integrations/honeybadger/notifier.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Superkick
+  module Integrations
+    module Honeybadger
+      # Sends structured events to Honeybadger Insights via the Events API.
+      #
+      # Honeybadger Insights is a structured event and log ingestion product.
+      # Events appear in the Insights dashboard where they can be searched,
+      # filtered, graphed, and used to trigger alerts.
+      #
+      # Stateful: tracks `spawned_at` per agent to compute duration on terminal
+      # events. Duration is included in the event payload.
+      #
+      # Template support:
+      #   Event formatting (message, severity, payload fields) is defined via
+      #   Liquid templates with custom block tags. Users can override per-event-type
+      #   or the default template.
+      #
+      #   Block tags: {% event_message %}, {% severity %}, {% payload_field key: "name" %}
+      #   Filters: `honeybadger_severity`
+      #
+      #   Templates are resolved from:
+      #     1. ~/.superkick/templates/notifications/honeybadger/<event_type>.liquid
+      #     2. <bundled>/notification_templates/<event_type>.liquid
+      #     3. ~/.superkick/templates/notifications/honeybadger/default.liquid
+      #     4. <bundled>/notification_templates/default.liquid
+      #
+      # Configuration:
+      #
+      #   notifications:
+      #     - type: honeybadger
+      #       api_key: <%= env("HONEYBADGER_API_KEY") %>
+      #       tags:                          # optional additional tags
+      #         - production
+      #         - team-alpha
+      #
+      # Each event is sent as newline-delimited JSON to the Honeybadger Events
+      # API endpoint. Events include:
+      #   - event_type: the Superkick event type (e.g. "agent_completed")
+      #   - agent_id, monitor_type, monitor_name: standard Superkick metadata
+      #   - message: the human-readable notification message
+      #   - severity: mapped from event type (error/warning/info)
+      #   - duration_seconds: time since agent_spawned (on terminal events only)
+      #   - tags: user-configured tags array
+      class Notifier < Superkick::Notifier
+        def self.type = :honeybadger
+
+        def self.templates_dir = File.expand_path("notification_templates", __dir__)
+
+        def self.setup_label = "Honeybadger"
+
+        def self.setup_config
+          <<~YAML
+            - type: honeybadger
+              api_key: <%= env("HONEYBADGER_API_KEY") %>
+              # tags:                            # optional tags
+              #   - production
+          YAML
+        end
+
+        API_URL = "https://api.honeybadger.io"
+        EVENTS_PATH = "/v1/events"
+        TIMEOUT = 10
+
+        SEVERITY_MAP = {
+          "agent_completed" => "info",
+          "agent_failed" => "error",
+          "agent_timed_out" => "warning",
+          "agent_blocked" => "warning",
+          "agent_stalled" => "warning",
+          "agent_terminated" => "warning",
+          "agent_spawned" => "info",
+          "agent_claimed" => "info",
+          "agent_unclaimed" => "info",
+          "agent_pending_approval" => "info",
+          "workflow_triggered" => "info",
+          "workflow_iterations_exceeded" => "warning",
+          "budget_warning" => "warning",
+          "budget_exceeded" => "error",
+          "team_created" => "info",
+          "team_completed" => "info",
+          "team_failed" => "error",
+          "team_timed_out" => "warning",
+          "worker_spawned" => "info",
+          "teammate_message" => "info",
+          "teammate_blocker" => "warning",
+          "attach_promoted" => "info",
+          "attach_demoted" => "info",
+          "attach_idle_timeout" => "warning",
+          "attach_force_takeover" => "warning",
+          "agent_update" => "info",
+          "artifact_published" => "info"
+        }.freeze
+
+        liquid do
+          context do
+            attribute :message
+            attribute :severity
+            attribute :payload, default: -> { {} }
+          end
+
+          filter :honeybadger_severity do |event_type|
+            Superkick::Integrations::Honeybadger::Notifier::SEVERITY_MAP.fetch(event_type.to_s, "info")
+          end
+
+          block :event_message do |ctx, text, _attrs|
+            ctx.message = text
+          end
+
+          block :severity do |ctx, text, _attrs|
+            ctx.severity = text
+          end
+
+          block :payload_field do |ctx, text, attrs|
+            name = attrs["key"]
+            ctx.payload[name] = text if name && !text.empty?
+          end
+        end
+
+        def initialize(api_key: nil, tags: [], connection: nil, **opts)
+          super(**opts)
+          @api_key = api_key
+          @tags = Array(tags)
+          @connection = connection
+        end
+
+        def stateful? = true
+
+        def agent_finished(agent_id:)
+          @state_store.delete(:honeybadger, agent_id.to_s)
+        end
+
+        def notify(payload)
+          unless @api_key
+            Superkick.logger.warn("notifier:honeybadger") { "No api_key configured" }
+            return
+          end
+
+          event_type = payload[:event_type]
+          agent_id = payload[:agent_id]
+
+          # Track spawn time for duration computation
+          if event_type == "agent_spawned" && agent_id && !agent_id.empty?
+            @state_store.put(:honeybadger, agent_id, {spawned_at: Process.clock_gettime(Process::CLOCK_MONOTONIC)}) unless @state_store.get(:honeybadger, agent_id)
+          end
+
+          event = build_event(payload)
+          post_event(event)
+        rescue => e
+          Superkick.logger.warn("notifier:honeybadger") { "Failed: #{e.message}" }
+        end
+
+        private
+
+        def build_event(payload)
+          event_type = payload[:event_type]
+          agent_id = payload[:agent_id]
+
+          template_result = render_notification(payload)
+
+          if template_result && template_result[:structured]
+            structured = template_result[:structured]
+            message = structured.message || payload[:message]
+            severity = structured.severity || SEVERITY_MAP.fetch(event_type, "info")
+          else
+            message = payload[:message]
+            severity = SEVERITY_MAP.fetch(event_type, "info")
+          end
+
+          event = {
+            ts: payload[:timestamp] || Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            event_type: "superkick.#{event_type}",
+            severity:,
+            message:,
+            agent_id:,
+            source: "superkick"
+          }
+
+          # Add template-driven payload fields or fall back to hardcoded fields
+          if template_result && template_result[:structured] && !template_result[:structured].payload.empty?
+            template_result[:structured].payload.each do |key, value|
+              event[key.to_sym] = value
+            end
+          else
+            monitor = payload[:monitor]
+            if monitor
+              event[:monitor_type] = monitor.type unless monitor.type.to_s.empty?
+              event[:monitor_name] = monitor.name unless monitor.name.to_s.empty?
+            end
+
+            ctx = payload[:context] || {}
+            team = ctx[:team]
+            event[:team_id] = team.id if team&.id
+            agent = ctx[:agent]
+            event[:team_role] = agent.role if agent&.role
+            spawner = ctx[:spawner]
+            event[:spawner_name] = spawner.name.to_s if spawner
+            agent_drop = ctx[:agent]
+            event[:cost_usd] = agent_drop.cost_usd if agent_drop&.cost_usd
+          end
+
+          event[:tags] = @tags unless @tags.empty?
+
+          # Add duration on terminal events — prefer agent.spawned_at, fall back to local tracking
+          if terminal_event?(event_type) && agent_id && !agent_id.empty?
+            agent_drop = payload.dig(:context, :agent)
+            duration = if agent_drop&.spawned_at
+              (Time.now.utc - Time.parse(agent_drop.spawned_at)).round(1)
+            else
+              state = @state_store.get(:honeybadger, agent_id)
+              (Process.clock_gettime(Process::CLOCK_MONOTONIC) - state[:spawned_at]).round(1) if state&.dig(:spawned_at)
+            end
+            event[:duration_seconds] = duration if duration
+          end
+
+          event
+        end
+
+        def post_event(event)
+          conn = @connection || build_connection
+          response = conn.post(EVENTS_PATH) do |req|
+            req.body = JSON.generate(event) + "\n"
+          end
+
+          unless (200..299).cover?(response.status)
+            Superkick.logger.warn("notifier:honeybadger") { "API returned HTTP #{response.status}" }
+          end
+        end
+
+        def build_connection
+          Faraday.new(url: API_URL) do |f|
+            f.headers["Content-Type"] = "application/json"
+            f.headers["X-API-Key"] = @api_key
+            f.options.timeout = TIMEOUT
+            f.options.open_timeout = TIMEOUT
+          end
+        end
+
+        def terminal_event?(event_type)
+          %w[agent_completed agent_failed agent_timed_out agent_terminated
+            team_completed team_failed team_timed_out].include?(event_type)
+        end
+      end
+    end
+  end
+end