rubyn-code 0.5.1 → 0.8.0

data/lib/rubyn_code/chisel/inspection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Chisel
+    # Builds the over-engineering audit instruction shared by /chisel-review
+    # (scope: :diff) and /chisel-audit (scope: :repo). Both judge by the same
+    # decision ladder and exclude the same safety floor, so the two commands
+    # can never drift apart — they differ only in what code they look at.
+    #
+    # Detection is delegated to the agent and its tools (git_diff, bash, grep,
+    # read_file); this module only assembles the prompt.
+    module Inspection
+      SMELLS = <<~SMELLS.strip
+        Flag code that skips a rung of the ladder:
+        - speculative abstractions, wrappers, or base classes with a single caller
+        - reinvented stdlib or already-installed-gem functionality
+        - needless indirection, configurability, or options nobody uses
+        - dead parameters, unused branches, premature generalization
+        - a class where a method would do; a method where one line would do
+      SMELLS
+
+      OUTPUT_CONTRACT = <<~CONTRACT.strip
+        Return a ranked deletion/simplification list, most impactful first. For
+        each item give:
+        - `file:line`
+        - what it is (one line)
+        - which rung of the ladder it skipped
+        - the concrete simpler form (delete it / inline it / replace with stdlib X)
+
+        If nothing is over-engineered, say so plainly instead of inventing work.
+      CONTRACT
+
+      READ_ONLY_NOTE = 'This is a READ-ONLY review: report the list, do not edit any files.'
+
+      module_function
+
+      # @param scope [Symbol] :diff (review changes) or :repo (audit codebase)
+      # @param target [String, nil] base ref for :diff (default "main"),
+      #   or an optional path to scope :repo
+      # @return [String] the full instruction to send to the agent
+      # @raise [ArgumentError] on an unknown scope
+      def prompt(scope:, target: nil)
+        [lead_in(scope, target), Chisel::LADDER, SMELLS, OUTPUT_CONTRACT, guardrails]
+          .join("\n\n")
+      end
+
+      # Read-only guard + the shared safety floor, reused verbatim from Chisel
+      # so the exclusion list can never drift from the always-on ruleset.
+      #
+      # @return [String]
+      def guardrails
+        "#{READ_ONLY_NOTE}\n\n#{Chisel::SAFETY_FLOOR}\n" \
+          'Those are never over-engineering — leave them even if they add code.'
+      end
+
+      # @return [String]
+      def lead_in(scope, target)
+        case scope
+        when :diff then diff_lead_in(presence(target) || 'main')
+        when :repo then repo_lead_in(presence(target))
+        else raise ArgumentError, "unknown Chisel inspection scope: #{scope.inspect}"
+        end
+      end
+
+      # @param value [#to_s, nil]
+      # @return [String, nil] the trimmed value, or nil if blank
+      def presence(value)
+        str = value.to_s.strip
+        str.empty? ? nil : str
+      end
+
+      def diff_lead_in(base)
+        <<~LEAD.strip
+          Chisel review — find over-engineering in my current changes.
+
+          Gather the diff with `git diff #{base}...` plus any uncommitted changes
+          (`git diff` and `git diff --staged`). Judge ONLY the added or changed
+          lines against the Chisel decision ladder below.
+        LEAD
+      end
+
+      def repo_lead_in(path)
+        scope_line = path ? "Scope the sweep to `#{path}`." : 'Sweep the whole repository.'
+        <<~LEAD.strip
+          Chisel audit — find accumulated over-engineering in this codebase.
+
+          #{scope_line} Use grep and file reads to survey the code, then judge it
+          against the Chisel decision ladder below.
+        LEAD
+      end
+    end
+  end
+end

data/lib/rubyn_code/chisel.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RubynCode
+  # Chisel is rubyn-code's opt-in "write the minimum that works" enforcement
+  # layer. It is OFF by default and only changes the agent's behavior once a
+  # user turns it on (via `/chisel full` or the config key `chisel_mode`).
+  #
+  # The single source of truth for:
+  #   - which intensity modes exist (off/lite/full/ultra),
+  #   - which mode is currently active (env override → config → default),
+  #   - the ruleset text injected into the system prompt at each intensity.
+  #
+  # The decision ladder is adapted from the open-source `ponytail` plugin and
+  # rebuilt natively here; the safety floor (validation, error/data-loss
+  # handling, security, accessibility) is never on the chopping block.
+  module Chisel
+    # On-demand over-engineering audit shared by /chisel-review and /chisel-audit.
+    autoload :Inspection, 'rubyn_code/chisel/inspection'
+    # Harvests inline `chisel:` deferral markers for /chisel-debt and /chisel-gain.
+    autoload :Debt, 'rubyn_code/chisel/debt'
+
+    MODES = %w[off lite full ultra].freeze
+    DEFAULT_MODE = 'off'
+    ENV_KEY = 'RUBYN_CHISEL_MODE'
+    CONFIG_KEY = 'chisel_mode'
+
+    # The decision ladder — injected at every non-off intensity.
+    LADDER = <<~LADDER.strip
+      # Chisel — write the minimum that works
+
+      Before writing code, stop at the first rung that holds:
+      1. Does this need to exist? If not, don't write it. (YAGNI)
+      2. Does Ruby's stdlib already do it? Use it.
+      3. Does the framework or runtime already do it? Use it.
+      4. Does an already-installed gem do it? Use it — don't add a dependency.
+      5. Is it one line? Write one line.
+      6. Only then: the smallest change that fully solves the task.
+    LADDER
+
+    # Extra guidance layered on at `full` and above.
+    FULL_ADDENDUM = <<~FULL.strip
+      Prefer editing existing code over adding new files, classes, or layers of
+      indirection. Don't introduce an abstraction until a second concrete caller
+      exists — three similar lines beat a premature framework.
+    FULL
+
+    # Extra guidance layered on at `ultra` only.
+    ULTRA_ADDENDUM = <<~ULTRA.strip
+      Be aggressive: question every new method, parameter, option, and file. If
+      you can't name the second caller, inline it. When you finish, briefly note
+      what you deliberately chose NOT to build.
+    ULTRA
+
+    # The safety floor — appended at every non-off intensity, last so it is
+    # never overridden by the "delete more" guidance above it.
+    SAFETY_FLOOR = <<~SAFETY.strip
+      Lazy, not negligent. Never chisel away: input and trust-boundary
+      validation, error and data-loss handling, security, or accessibility.
+    SAFETY
+
+    module_function
+
+    # @param value [#to_s]
+    # @return [Boolean] whether the value is a recognized mode
+    def valid?(value)
+      MODES.include?(value.to_s)
+    end
+
+    # Resolve the active mode: env override → persisted config → default.
+    # Each layer is normalized (trimmed + downcased) the same way the
+    # `/chisel` command normalizes its argument, so `RUBYN_CHISEL_MODE=Full`
+    # and a hand-edited `chisel_mode: " Full "` both resolve cleanly. Any
+    # unrecognized value falls through rather than raising, so a typo can
+    # never break a turn.
+    #
+    # @return [String] one of MODES
+    def mode
+      normalize(ENV.fetch(ENV_KEY, nil)) ||
+        normalize(configured_mode) ||
+        DEFAULT_MODE
+    end
+
+    # Trim + downcase a candidate mode, returning it only if recognized,
+    # otherwise nil so the caller can fall through to the next layer.
+    #
+    # @param value [#to_s, nil]
+    # @return [String, nil]
+    def normalize(value)
+      return nil if value.nil?
+
+      candidate = value.to_s.strip.downcase
+      valid?(candidate) ? candidate : nil
+    end
+
+    # @return [Boolean]
+    def enabled?
+      mode != 'off'
+    end
+
+    # The text Chisel contributes to the system prompt for the active mode.
+    #
+    # @return [String] "" when off; otherwise ladder + intensity addenda +
+    #   safety floor.
+    def prompt_section
+      current = mode
+      return '' if current == 'off'
+
+      parts = [LADDER]
+      parts << FULL_ADDENDUM if %w[full ultra].include?(current)
+      parts << ULTRA_ADDENDUM if current == 'ultra'
+      parts << SAFETY_FLOOR
+      parts.join("\n\n")
+    end
+
+    # The persisted mode from config, or nil if unreadable. Isolated so prompt
+    # assembly never dies on a malformed config file.
+    #
+    # @return [String, nil]
+    def configured_mode
+      # No default needed — chisel_mode lives in Settings::DEFAULT_MAP, so an
+      # unset key already resolves to DEFAULT_MODE.
+      Config::Settings.new.get(CONFIG_KEY)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/agents.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/agents` — list the sub-agent types available to spawn_agent: the
+      # built-in explore/worker plus any custom agents defined in
+      # .rubyn-code/agents/*.md or ~/.rubyn-code/agents/*.md.
+      class Agents < Base
+        def self.command_name = '/agents'
+        def self.description  = 'List available sub-agent types (built-in + custom)'
+
+        def execute(_args, ctx)
+          catalog = RubynCode::SubAgents::Catalog.new(project_root: ctx.project_root)
+          ctx.renderer.info('Available sub-agent types:')
+          catalog.all.each do |agent|
+            tag = agent.custom? ? '(custom)' : '(built-in)'
+            access = agent.read_only? ? 'read-only' : 'read/write'
+            puts "  #{agent.name.ljust(18)} #{tag} [#{access}] — #{agent.description}"
+          end
+          puts
+          ctx.renderer.info('Define your own in .rubyn-code/agents/<name>.md') if catalog.custom_names.empty?
+          nil
+        rescue StandardError => e
+          ctx.renderer.error("Could not list agents: #{e.message}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Set or report the Chisel intensity. Chisel is the opt-in "write the
+      # minimum that works" enforcement layer; it is off by default and only
+      # changes the agent's behavior once turned on here.
+      class Chisel < Base
+        def self.command_name = '/chisel'
+        def self.description = 'Set or show Chisel intensity (off|lite|full|ultra)'
+
+        def execute(args, ctx)
+          arg = args.first
+          return report(ctx) if arg.nil? || arg.strip.empty?
+
+          mode = arg.strip.downcase
+          return reject(mode, ctx) unless RubynCode::Chisel.valid?(mode)
+
+          persist(mode, ctx)
+        end
+
+        private
+
+        def report(ctx)
+          current = RubynCode::Chisel.mode
+          ctx.renderer.info("Chisel: #{current}")
+          ctx.renderer.info("Modes: #{RubynCode::Chisel::MODES.join(' | ')}")
+          ctx.renderer.info('Set with: /chisel full')
+        end
+
+        def persist(mode, ctx)
+          settings = Config::Settings.new
+          settings.set(RubynCode::Chisel::CONFIG_KEY, mode)
+          settings.save!
+          ctx.renderer.info(confirmation(mode))
+        end
+
+        def confirmation(mode)
+          return 'Chisel off — agent behaves normally.' if mode == 'off'
+
+          "Chisel set to #{mode} — the agent will favor writing the minimum that works."
+        end
+
+        def reject(mode, ctx)
+          ctx.renderer.warning("Unknown Chisel mode: #{mode}")
+          ctx.renderer.info("Valid modes: #{RubynCode::Chisel::MODES.join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_audit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-audit` — sweep the repo (or a path) for accumulated
+      # over-engineering and report a ranked deletion list. Read-only.
+      class ChiselAudit < Base
+        def self.command_name = '/chisel-audit'
+        def self.description = 'Find over-engineering across the repo (/chisel-audit [path])'
+
+        def execute(args, ctx)
+          path = args.first
+          ctx.send_message(RubynCode::Chisel::Inspection.prompt(scope: :repo, target: path))
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_debt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-debt` — harvest inline `chisel:` deferral markers from the
+      # codebase into a ledger view so postponed simplifications aren't lost.
+      class ChiselDebt < Base
+        def self.command_name = '/chisel-debt'
+        def self.description = 'List deferred `chisel:` markers in the codebase'
+
+        def execute(_args, ctx)
+          items = RubynCode::Chisel::Debt.scan(ctx.project_root)
+          return ctx.renderer.info('No chisel: debt markers found — clean.') if items.empty?
+
+          ctx.renderer.info("Chisel debt — #{items.size} deferred #{pluralize(items.size, 'simplification')}:")
+          items.each { |item| ctx.renderer.info("  #{item.file}:#{item.line} — #{item.note}") }
+        end
+
+        private
+
+        def pluralize(count, word)
+          count == 1 ? word : "#{word}s"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_gain.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-gain` — quick read on Chisel's status and what it buys you.
+      class ChiselGain < Base
+        def self.command_name = '/chisel-gain'
+        def self.description = 'Show Chisel status and reference impact'
+
+        # Measured on a real open-source repo for the approach Chisel is built on;
+        # shown as an attributed reference, not fabricated per-user metrics (which
+        # rubyn-code does not instrument).
+        REFERENCE_IMPACT = 'Reference benchmark for this approach (real FastAPI + React repo): ' \
+                           '~54% less code, ~20% cheaper, ~27% faster.'
+
+        def execute(_args, ctx)
+          mode = RubynCode::Chisel.mode
+          debt = RubynCode::Chisel::Debt.scan(ctx.project_root).size
+
+          ctx.renderer.info("Chisel mode: #{mode}")
+          ctx.renderer.info('Turn it on with /chisel full.') if mode == 'off'
+          ctx.renderer.info("Outstanding chisel: debt markers: #{debt}")
+          ctx.renderer.info(REFERENCE_IMPACT)
+          ctx.renderer.info('Run /chisel-review for concrete cuts in your current diff.')
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/chisel_review.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-review` — audit the current branch's changes for
+      # over-engineering and report a ranked deletion list. Read-only.
+      class ChiselReview < Base
+        def self.command_name = '/chisel-review'
+        def self.description = 'Find over-engineering in the current diff (/chisel-review [base])'
+
+        def execute(args, ctx)
+          # Inspection owns the 'main' default so it lives in exactly one place.
+          ctx.send_message(RubynCode::Chisel::Inspection.prompt(scope: :diff, target: args.first))
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/command_template.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Renders a user-defined slash-command body into a prompt, mirroring
+      # Claude Code's command templating:
+      #
+      #   $ARGUMENTS   → all args, space-joined
+      #   $1 .. $9     → positional args
+      #   !`shell cmd` → replaced with the command's (combined) output
+      #
+      # Bash substitution runs the user's own command file, so it carries the
+      # same trust as user hooks. Output is captured defensively and capped.
+      class CommandTemplate
+        BANG = /!`([^`]+)`/
+        POSITIONAL = /\$([1-9])/
+        MAX_BASH_OUTPUT = 16 * 1024
+
+        def initialize(body)
+          @body = body.to_s
+        end
+
+        # @param args [Array<String>] arguments passed after the command name
+        # @return [String] the rendered prompt
+        def render(args = [])
+          text = substitute_bash(@body)
+          text = text.gsub('$ARGUMENTS', args.join(' '))
+          text.gsub(POSITIONAL) { args[Regexp.last_match(1).to_i - 1].to_s }
+        end
+
+        private
+
+        def substitute_bash(text)
+          text.gsub(BANG) { run(Regexp.last_match(1)) }
+        end
+
+        def run(cmd)
+          out, = Open3.capture2e(cmd)
+          out = "#{out.byteslice(0, MAX_BASH_OUTPUT)}\n… [truncated]" if out.bytesize > MAX_BASH_OUTPUT
+          out.strip
+        rescue StandardError => e
+          "[command failed: #{e.message}]"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/context.rb

@@ -21,7 +21,9 @@ module RubynCode
         :background_worker,
         :permission_tier,
         :plan_mode,
-        :message_handler
+        :message_handler,
+        :hook_registry,
+        :checkpoint_manager
       ) do
         # Convenience: return a new Context with a message handler attached.
         # Used by commands like /review that delegate to the LLM.
@@ -38,6 +40,33 @@ module RubynCode
 
         # @return [Boolean]
         def plan_mode? = plan_mode
+
+        # Restrict the tool set for a single agent invocation. The next
+        # `send_message` call inside the block sees only the tools in
+        # `allowed`; the override is cleared after the call.
+        def with_allowed_tools(allowed = nil, &block)
+          apply_loop_override(:allowed_tools_override=, allowed, &block)
+        end
+
+        # Apply a one-shot model override for the duration of a block.
+        def with_optional_model(model_name = nil, &block)
+          apply_loop_override(:model_override=, model_name, &block)
+        end
+
+        private
+
+        # Set an override on the agent loop (when one is wired in) for the
+        # duration of the block, then clear it. Custom commands without
+        # a loop (e.g. test doubles) fall through to a plain yield.
+        def apply_loop_override(method, value)
+          loop = agent_loop
+          return yield unless loop.respond_to?(method)
+
+          loop.public_send(method, value)
+          yield
+        ensure
+          loop&.public_send(method, nil) if loop.respond_to?(method)
+        end
       end
     end
   end

data/lib/rubyn_code/cli/commands/custom_command.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # A slash command defined by a user markdown file (loaded by
+      # CustomLoader). Unlike the built-in commands — which are registered as
+      # classes — this is a ready instance: the Registry dispatches it directly.
+      #
+      # Executing it renders the template (argument / bash substitution) and
+      # sends the result to the agent as a normal prompt.
+      class CustomCommand
+        # @return [String] command name without the leading slash
+        attr_reader :name
+        # @return [String] one-line description for /help
+        attr_reader :description
+        # @return [String, nil] argument hint shown next to the name in /help
+        attr_reader :argument_hint
+        # @return [Array<String>, nil] tool names the command restricts to
+        attr_reader :allowed_tools
+        # @return [String, nil] model override for this prompt
+        attr_reader :model
+        # @return [String, nil] originating file path
+        attr_reader :source
+
+        def initialize(name:, description:, body:, # rubocop:disable Metrics/ParameterLists -- explicit kwargs document the frontmatter surface
+                       source: nil,
+                       argument_hint: nil, allowed_tools: nil, model: nil)
+          @name = name
+          @description = description
+          @template = CommandTemplate.new(body)
+          @argument_hint = argument_hint
+          @allowed_tools = allowed_tools
+          @model = model
+          @source = source
+        end
+
+        def command_name = "/#{@name}"
+        def aliases = [].freeze
+        def hidden? = false
+        def all_names = [command_name].freeze
+
+        # Render the help label, including [hint] when frontmatter provides one.
+        # The argument_hint is expected to be the placeholder text already wrapped
+        # in [ ] (e.g. "[env]") — we don't add another set of brackets.
+        def help_label
+          hint = @argument_hint.to_s.strip
+          hint.empty? ? description : "#{description}  #{hint}"
+        end
+
+        # @return [Boolean] true if the frontmatter restricted the tool set
+        def restricts_tools?
+          !@allowed_tools.nil? && !@allowed_tools.empty?
+        end
+
+        # @return [Boolean] true if the frontmatter overrode the model
+        def overrides_model?
+          !@model.to_s.strip.empty?
+        end
+
+        # @param args [Array<String>]
+        # @param ctx [Commands::Context]
+        # @return [nil]
+        def execute(args, ctx)
+          rendered = @template.render(args)
+          if restricts_tools?
+            ctx.with_allowed_tools(@allowed_tools) do
+              ctx.with_optional_model(@model) do
+                ctx.send_message(rendered)
+              end
+            end
+          elsif overrides_model?
+            ctx.with_optional_model(@model) do
+              ctx.send_message(rendered)
+            end
+          else
+            ctx.send_message(rendered)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/custom_loader.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Discovers user-defined slash commands from markdown files, mirroring
+      # Claude Code's `.claude/commands/*.md`:
+      #
+      #   <project>/.rubyn-code/commands/*.md   (project-local, takes priority)
+      #   ~/.rubyn-code/commands/*.md           (user-global)
+      #
+      # Each `deploy.md` becomes `/deploy`. Optional YAML frontmatter supplies
+      # the `description`; otherwise the first non-empty line is used. The body
+      # is the prompt template (see CommandTemplate for substitutions).
+      module CustomLoader
+        FRONTMATTER = /\A---\s*\n(.+?\n)---\s*\n(.*)\z/m
+        NAME = /\A[a-z0-9][a-z0-9_-]*\z/i
+
+        class << self
+          # @return [Array<CustomCommand>] unique commands (project overrides user)
+          def load_all(project_root:, home_dir: Config::Defaults::HOME_DIR)
+            dirs = [
+              project_root && File.join(project_root, '.rubyn-code', 'commands'),
+              File.join(home_dir, 'commands')
+            ].compact
+            dirs.flat_map { |dir| load_dir(dir) }.uniq(&:command_name)
+          end
+
+          def load_dir(dir)
+            return [] unless Dir.exist?(dir)
+
+            Dir.glob(File.join(dir, '*.md')).filter_map { |path| build(path) }
+          end
+
+          private
+
+          def build(path)
+            name = File.basename(path, '.md').strip
+            return nil unless name.match?(NAME)
+
+            meta, body = parse(File.read(path))
+            description = meta['description'].to_s
+            description = "Custom command: /#{name}" if description.strip.empty?
+            CustomCommand.new(
+              name: name,
+              description: description,
+              body: body,
+              source: path,
+              argument_hint: blank_to_nil(stringify(meta['argument_hint'] || meta['argument-hint'])),
+              allowed_tools: list_of_tools(meta['allowed_tools'] || meta['allowed-tools']),
+              model: blank_to_nil(stringify(meta['model']))
+            )
+          rescue StandardError => e
+            RubynCode::Debug.warn("Failed to load custom command #{path}: #{e.message}")
+            nil
+          end
+
+          def parse(content)
+            if (match = FRONTMATTER.match(content))
+              frontmatter = YAML.safe_load(match[1]) || {}
+              [frontmatter, match[2].to_s.strip]
+            else
+              body = content.to_s.strip
+              [{ 'description' => first_line(body) }, body]
+            end
+          end
+
+          def blank_to_nil(value)
+            value.to_s.strip.empty? ? nil : value
+          end
+
+          def stringify(value)
+            return '' if value.nil?
+
+            # YAML's flow-style `[env]` is parsed as a single-element array.
+            # Stringify the array element directly so users see exactly the
+            # characters they typed.
+            str = value.is_a?(Array) ? value.join : value
+            str.to_s.strip
+          end
+
+          def list_of_tools(value)
+            return nil if value.nil?
+
+            arr = value.is_a?(Array) ? value : value.to_s.split(',')
+            cleaned = arr.map { |name| name.to_s.strip }.reject(&:empty?)
+            cleaned.empty? ? nil : cleaned
+          end
+
+          def first_line(body)
+            line = body.lines.first.to_s.strip
+            line.sub(/\A#+\s*/, '')[0, 80]
+          end
+        end
+      end
+    end
+  end
+end