rubino-agent 0.3.0

data/lib/rubino/cli/setup_command.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rubino
+  module CLI
+    # Handles initial setup: creates config directory, default config,
+    # initializes the database, and runs migrations.
+    class SetupCommand
+      def execute
+        ui = Rubino.ui
+
+        ui.info("Setting up rubino...")
+        ui.blank_line
+
+        # Create home directory (0700 — only the owner sees stored secrets)
+        # and subdirectories. ensure_directories! owns the mkdir + chmod so
+        # every entry point that materializes the home agrees on 0700 (#65).
+        home = Rubino.home_path
+        Rubino.ensure_directories!
+        ui.success("Home directory: #{home}")
+        ui.success("Subdirectories created")
+
+        # Create config file if it doesn't exist
+        loader = Config::Loader.new
+        if loader.config_exists?
+          ui.warning("Config already exists: #{loader.config_path}")
+        else
+          loader.create_default_config!
+          File.chmod(0o600, loader.config_path)
+          ui.success("Config created: #{loader.config_path}")
+        end
+
+        # Create .env template if it doesn't exist (0600 — contains api keys)
+        env_path = File.join(home, ".env")
+        unless File.exist?(env_path)
+          File.write(env_path, env_template)
+          File.chmod(0o600, env_path)
+          ui.success("Env template created: #{env_path}")
+        end
+
+        # Initialize database
+        ui.status("Initializing database...")
+        connection = Rubino.database
+        migrator = Database::Migrator.new(connection)
+        migrator.migrate!
+        ui.success("Database initialized: #{connection.db_path}")
+
+        # First-run onboarding: if no usable key is configured yet AND we're on
+        # a real TTY, guide the user to a working model (provider/model/key)
+        # right here so `setup` ends in a usable config — not a dead-end that
+        # still needs hand-editing config.yml (#93). Non-interactive setup keeps
+        # the old behaviour (files created, no prompts).
+        maybe_run_onboarding(ui)
+
+        ui.blank_line
+        # Tell the truth about the end state (#31). A green "Setup complete!" is
+        # only honest when a usable credential is actually configured — printing
+        # it after a skipped/abandoned onboarding (no provider, no key) directly
+        # contradicts the state. Re-check the credential after onboarding so the
+        # final line reflects reality on both the interactive and the
+        # non-interactive (files-only) paths.
+        if LLM::CredentialCheck.usable?
+          ui.success("Setup complete! Run 'rubino doctor' to verify.")
+        else
+          ui.warning("Setup files created, but no model is configured yet.")
+          ui.status("Run 'rubino setup' again or add an API key, then 'rubino doctor' to verify.")
+        end
+      end
+
+      private
+
+      def maybe_run_onboarding(ui)
+        return unless interactive?
+        return if LLM::CredentialCheck.usable?
+
+        OnboardingWizard.new(ui: ui).run
+      end
+
+      def interactive?
+        $stdin.tty? && $stdout.tty?
+      rescue StandardError
+        false
+      end
+
+      def env_template
+        <<~ENV
+          # Rubino API Keys
+          # Add your API keys here. Do NOT commit this file.
+          # `rubino setup` (on a terminal) can fill one in for you.
+
+          # MiniMax (recommended default — Anthropic-compatible)
+          # MINIMAX_API_KEY=...
+
+          # OpenAI
+          # OPENAI_API_KEY=sk-...
+
+          # Anthropic
+          # ANTHROPIC_API_KEY=sk-ant-...
+
+          # Google
+          # GEMINI_API_KEY=...
+        ENV
+      end
+    end
+  end
+end

data/lib/rubino/cli/skills_command.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Rubino
+  module CLI
+    # Subcommands for managing skills (#188). `list` mirrors the in-chat
+    # /skills disclosure (enabled/disabled markers), `show` prints a skill's
+    # SKILL.md body (trust review before enabling), and `enable`/`disable`
+    # run the SAME registry-validated StateRepository write the HTTP API
+    # toggle and the in-chat `/skills enable|disable` use (Skills::Toggle) —
+    # no new logic, just the missing terminal surface.
+    class SkillsCommand < Thor
+      # Clean `tree`/help label instead of the underscored class-name default (F12).
+      namespace "rubino skills"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "list", "List skills with enabled/disabled markers"
+      def list
+        Rubino.ensure_database_ready!
+        registry = Skills::Registry.trusted
+        skills = registry.all
+        if skills.empty?
+          Rubino.ui.info("No skills found.")
+          Rubino.ui.info("Add .md files to .rubino/skills/ to create skills.")
+          return
+        end
+
+        rows = skills.map do |skill|
+          [skill.name, skill_status(skill.name, registry), skill.description.to_s]
+        end
+        Rubino.ui.table(headers: %w[Name Status Description], rows: rows)
+      end
+
+      desc "show NAME", "Print a skill's SKILL.md body (review it before enabling)"
+      def show(name)
+        skill = Skills::Registry.trusted.find(name)
+        if skill.nil?
+          Rubino.ui.error("unknown skill: #{name}")
+          return
+        end
+
+        Rubino.ui.info(skill.content)
+      end
+
+      desc "enable NAME", "Enable a skill (back into the index, every session)"
+      def enable(name)
+        toggle(name, enabled: true)
+      end
+
+      desc "disable NAME", "Disable a skill (drops out of the index, every session)"
+      def disable(name)
+        toggle(name, enabled: false)
+      end
+
+      private
+
+      # The Status cell: enabled/disabled from the StateRepository (the same
+      # source the in-chat list's "(disabled)" marker reads), plus the active
+      # pin when this process carries one (the slot is process-level, so a
+      # fresh CLI run normally shows none — the marker matters in-process).
+      def skill_status(name, registry)
+        status = registry.enabled?(name) ? "enabled" : "disabled"
+        status += " · active" if Rubino::ActiveSkill.current == name
+        status
+      end
+
+      def toggle(name, enabled:)
+        Rubino.ensure_database_ready!
+        registry = Skills::Registry.trusted
+        unless Skills::Toggle.set(name, enabled: enabled, registry: registry)
+          Rubino.ui.error("unknown skill: #{name}")
+          available = registry.names
+          Rubino.ui.info("Available: #{available.join(", ")}") unless available.empty?
+          return
+        end
+
+        Rubino.ui.success("#{enabled ? "Enabled" : "Disabled"} skill: #{name}")
+      end
+    end
+  end
+end

data/lib/rubino/cli/tools_command.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Rubino
+  module CLI
+    # Lists available tools and their status
+    class ToolsCommand
+      def execute
+        ui = Rubino.ui
+        config = Rubino.configuration
+
+        ui.info("Available Tools:")
+        ui.blank_line
+
+        # The registry is populated lazily when an agent runner boots; the bare
+        # `rubino tools` command never boots one, so without this the table
+        # is empty (F6). Registering the defaults is idempotent and matches what
+        # ChatCommand#ensure_setup! does before a turn.
+        Tools::Registry.register_defaults! if Tools::Registry.all.empty?
+
+        # Report against the SAME config gate the registry enforces: each row
+        # is a `tools.<config_key>` group, resolved exactly like
+        # Registry#tool_enabled_in_config? (opt-out — absent key = enabled).
+        # Deriving the rows from the registered tools' #config_key (rather
+        # than a hardcoded list) means the displayed state can never drift
+        # from reality — `web` no longer shows "disabled" while webfetch/
+        # websearch stay live, and the dead `browser` key is gone.
+        # MCP wrappers are excluded here: they are dynamic (no `tools.<key>`
+        # config gate) and get their own section below instead of fake rows
+        # in the config-group table.
+        builtins = Tools::Registry.all.grep_v(MCP::MCPToolWrapper)
+        config_keys = builtins.map(&:config_key).uniq
+        rows = config_keys.sort.map do |key|
+          value   = config.dig("tools", key)
+          enabled = value.nil? || value == true
+          [key, enabled ? "enabled" : "disabled"]
+        end
+
+        ui.table(headers: %w[Tool Status], rows: rows)
+
+        print_enable_hint(rows)
+        print_mcp_tools
+      end
+
+      private
+
+      # A disabled row with no pointer is a dead end (#20): name the exact
+      # config command that turns the group back on.
+      def print_enable_hint(rows)
+        disabled = rows.select { |_, status| status == "disabled" }.map(&:first)
+        return if disabled.empty?
+
+        ui = Rubino.ui
+        ui.blank_line
+        ui.info("Enable with: rubino config set tools.<name> true   (e.g. tools.#{disabled.first})")
+      end
+
+      # Lists tools from configured MCP servers (#91). Configuring
+      # `mcp.servers` is the opt-in: the Manager connects, prefixes each tool
+      # `servername_toolname`, and registers it alongside the built-ins. A
+      # configured-but-empty result still prints a breadcrumb (#94) so MCP
+      # users are never left staring at a silently builtin-only table —
+      # unreachable servers additionally warn via Manager#start_server.
+      def print_mcp_tools
+        return unless MCP.enabled?
+
+        ui = Rubino.ui
+        ui.blank_line
+        ui.info("MCP Tools (experimental):")
+        MCP.boot!
+
+        mcp_tools = Tools::Registry.all.grep(MCP::MCPToolWrapper)
+        if mcp_tools.empty?
+          ui.warning("mcp.servers configured, but no MCP tools loaded")
+        else
+          rows = mcp_tools.map { |t| [t.name, t.server_name] }.sort
+          ui.table(headers: %w[Tool Server], rows: rows)
+        end
+      end
+    end
+  end
+end

data/lib/rubino/cli/trust_gate.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rubino
+  module CLI
+    # The interactive folder-trust checkpoint. Asks ONCE per directory, before
+    # that directory's AGENTS.md / project context + .rubino/skills are honored,
+    # and remembers the answer in Rubino::Trust so it's never re-asked.
+    #
+    # Modelled on VS Code Workspace Trust + Claude Code's trust dialog. Declining
+    # is non-destructive (VS Code "Restricted Mode"): the session still runs, it
+    # just runs WITHOUT that directory's project context/skills (the assembler
+    # consults Rubino::Trust.trusted? before injecting them).
+    #
+    # Skipped entirely — no prompt, treated as allowed for the duration — when:
+    #   - the dir is already trusted,
+    #   - the dir has nothing to gate (no context file, no .rubino/skills),
+    #   - --ignore-rules was passed (project context is off regardless), or
+    #   - the run is non-interactive (-q / no TTY): we never block automation.
+    class TrustGate
+      def initialize(ui: nil, interactive: true, ignore_rules: false)
+        @ui = ui || Rubino.ui
+        @interactive = interactive
+        @ignore_rules = ignore_rules
+      end
+
+      # Ensures +dir+ has a trust decision. Returns true when the directory's
+      # project context/skills may be loaded, false when it must run in
+      # restricted mode. Prompts at most once, then remembers a "yes".
+      def ensure_trust(dir)
+        return true if Rubino::Trust.trusted?(dir)
+        return true if @ignore_rules            # context already suppressed
+        return true unless gateworthy?(dir)     # nothing to gate → no ceremony
+
+        # Non-interactive: never block. We also do NOT remember it (the user
+        # never vouched), so context stays withheld this run — Restricted Mode
+        # by default for automation, matching VS Code's headless behaviour.
+        return false unless @interactive
+
+        prompt(dir)
+      end
+
+      private
+
+      # Asks the one-time question and records the answer. Default is No.
+      def prompt(dir)
+        @ui.blank_line if @ui.respond_to?(:blank_line)
+        @ui.info("▸ Starting in #{dir} — its AGENTS.md and project skills will shape the agent.")
+        answer = @ui.ask("  Trust this folder? [y/N] ").to_s.strip.downcase
+
+        if answer.start_with?("y")
+          Rubino::Trust.remember(dir)
+          @ui.success("Trusted #{dir} — loading its project context and skills.") if @ui.respond_to?(:success)
+          true
+        else
+          @ui.info("Running in restricted mode — #{dir}'s AGENTS.md and skills will NOT be loaded.")
+          false
+        end
+      end
+
+      # A directory is only worth a trust prompt when it actually ships
+      # something rubino auto-injects: a project-context file or a skills dir.
+      # An empty scratch dir gets no prompt — there's nothing to be steered by.
+      def gateworthy?(dir)
+        Context::FileDiscovery.new(base_path: dir).discover_files.any? ||
+          File.directory?(File.join(dir, Skills::PromptIndex::DEFAULT_SKILL_DIR))
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/rubino/commands/built_ins.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    # Single source of truth for built-in slash command names + descriptions.
+    # Referenced by the CLI UI for tab-completion and by the Executor for
+    # `/help` and the unknown-command "Available" list (so both stay in sync —
+    # previously `/help` omitted /quit and /mode, L7).
+    module BuiltIns
+      # Ordered: name => one-line description shown by `/help`.
+      DESCRIPTIONS = {
+        "/status" => "Overview: model, mode, session, memory, background work",
+        "/sessions" => "List recent sessions; resume, show, or delete one (--all lifts the cap)",
+        "/new" => "Start a fresh session (the current one is left intact)",
+        "/clear" => "Alias for /new — start a fresh session",
+        "/probe" => "Ask an ephemeral side-question (not saved); tip: start a line with '? '",
+        "/queued" => "Queue a message to run after the current turn (Alt+Enter does the same)",
+        "/branch" => "Fork the current session into a new one and switch into it",
+        "/compact" => "Compact the context now: older turns become a summary",
+        "/export" => "Write the session transcript as markdown (/export [path])",
+        "/memory" => "Inspect/search/forget what the agent remembers (show ID, backend, --all)",
+        "/agents" => "List background subagents; steer/probe a running one, or view output",
+        "/tasks" => "Alias for /agents",
+        "/reply" => "Answer a subagent that is blocked waiting on you (ask_parent)",
+        "/jobs" => "List the background job queue (status counts); /jobs <id> for detail",
+        "/skills" => "List skills; activate one ('none' clears), or enable/disable NAME",
+        "/mcp" => "List MCP servers and their tools; restart or disable one",
+        "/add-dir" => "Add an extra allowed workspace directory (write/edit can reach it)",
+        "/dirs" => "List the current workspace roots",
+        "/config" => "Read or set configuration (/config <key> [value]; 'show' = full view)",
+        "/model" => "Show or switch the model for this session (/model <name>)",
+        "/mode" => "Show or switch mode (default | plan | yolo)",
+        "/reasoning" => "Show or switch how reasoning is shown (hidden | collapsed | full)",
+        "/think" => "Show or switch thinking effort (off | low | medium | high)",
+        "/commands" => "List custom commands (and how to make them)",
+        "/help" => "Show this help",
+        "/paste" => "Attach an image from the clipboard",
+        "/clear-images" => "Drop pending image attachments",
+        "/exit" => "End session",
+        "/quit" => "End session"
+      }.freeze
+
+      NAMES = DESCRIPTIONS.keys.freeze
+    end
+  end
+end

data/lib/rubino/commands/command.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Rubino
+  module Commands
+    # Represents a custom slash command loaded from a Markdown file.
+    # Supports $ARGUMENTS, $1-$9 positional params, @file refs.
+    #
+    # Shell injection via !`command` is opt-in and disabled by default.
+    # Enable it by setting commands.shell_injection_enabled: true in your
+    # configuration — only do so in trusted, controlled environments.
+    class Command
+      attr_reader :name, :description, :agent, :model, :path
+
+      def initialize(path:)
+        @path     = path
+        @metadata = {}
+        @template = nil
+        parse!
+      end
+
+      # Renders the command prompt with given arguments.
+      def render(arguments = "")
+        prompt = template.dup
+
+        substitute_arguments!(prompt, arguments)
+        process_shell_injections!(prompt)
+        process_file_references!(prompt)
+
+        prompt.strip
+      end
+
+      # Returns the raw template content.
+      def template
+        @template ||= load_template
+      end
+
+      private
+
+      # Replace $ARGUMENTS and positional $1..$9 params.
+      def substitute_arguments!(prompt, arguments)
+        prompt.gsub!("$ARGUMENTS", arguments)
+
+        args = arguments.split(/\s+/)
+        (1..9).each do |i|
+          prompt.gsub!("$#{i}", args[i - 1] || "")
+        end
+      end
+
+      # Process !`command` shell injections — only when explicitly enabled.
+      def process_shell_injections!(prompt)
+        return unless shell_injection_enabled?
+
+        prompt.gsub!(/!`([^`]+)`/) do
+          command = Regexp.last_match(1)
+          `#{command} 2>&1`.strip
+        end
+      end
+
+      # Replace @path/to/file references with file content.
+      def process_file_references!(prompt)
+        prompt.gsub!(%r{@([\w/._-]+)}) do
+          file_path = Regexp.last_match(1)
+          expanded  = File.expand_path(file_path)
+          if File.exist?(expanded)
+            File.read(expanded)
+          else
+            "@#{file_path} (file not found)"
+          end
+        end
+      end
+
+      def shell_injection_enabled?
+        Rubino.configuration.dig("commands", "shell_injection_enabled") == true
+      end
+
+      def parse!
+        raw = File.read(@path)
+
+        if raw.start_with?("---")
+          parts = raw.split("---", 3)
+          if parts.size >= 3
+            begin
+              @metadata = YAML.safe_load(parts[1], permitted_classes: [Symbol]) || {}
+            rescue Psych::SyntaxError => e
+              warn "rubino: skipping malformed frontmatter in #{@path} " \
+                   "(line #{e.line}: #{e.problem}); treating whole file as template"
+              @metadata = {}
+              @template = raw
+            end
+            unless @metadata.is_a?(Hash)
+              warn "rubino: ignoring non-Hash frontmatter in #{@path}; treating whole file as template"
+              @metadata = {}
+              @template = raw
+            end
+            @template ||= parts[2].strip
+          else
+            @template = raw
+          end
+        else
+          @template = raw
+        end
+
+        @name        = (@metadata["name"] || File.basename(@path, ".md")).to_s
+        @description = @metadata["description"] || ""
+        @agent       = @metadata["agent"]
+        @model       = @metadata["model"]
+      end
+
+      def load_template
+        @template
+      end
+    end
+  end
+end