rubyn 0.1.0

data/lib/rubyn/commands/agent.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Rubyn
+  module Commands
+    class Agent < Base
+      MAX_TOOL_ROUNDS = 25
+      MAX_PARAM_DISPLAY_LENGTH = 50
+
+      def execute
+        formatter = Rubyn::Output::Formatter
+        ensure_configured!
+        auto_index_if_needed!
+
+        formatter.header("Rubyn Agent")
+        formatter.info("Type your message. Use @filename to attach files.")
+        formatter.info("Commands: /quit /credits /new")
+        formatter.newline
+
+        @conversation_id = nil
+        @project_token = project_token
+        @executor = Rubyn::Tools::Executor.new(Dir.pwd)
+
+        loop do
+          print "you> "
+          input = $stdin.gets
+          break if input.nil?
+
+          input = input.strip
+          break if ["/quit", "exit"].include?(input)
+
+          next if input.empty?
+
+          dispatch_input(input, formatter)
+        end
+
+        formatter.newline
+        formatter.info("Session ended.")
+      end
+
+      private
+
+      def dispatch_input(input, formatter)
+        case input
+        when "/credits"
+          show_credits(formatter)
+        when "/new"
+          @conversation_id = nil
+          formatter.info("New conversation started.")
+        else
+          send_message(input, formatter)
+        end
+      end
+
+      def send_message(input, formatter)
+        file_context = extract_file_context(input)
+        message = input.gsub(/@\S+/, "").strip
+
+        begin
+          result = Rubyn.api_client.agent_message(
+            conversation_id: @conversation_id,
+            message: message,
+            file_context: file_context,
+            project_token: @project_token
+          )
+
+          @conversation_id ||= result["conversation_id"]
+
+          display_agent_result(result, formatter)
+        rescue Rubyn::AuthenticationError => e
+          formatter.error("Authentication failed: #{e.message}")
+        rescue Rubyn::APIError => e
+          formatter.error(e.message)
+        end
+      end
+
+      def display_agent_result(result, formatter)
+        if result.fetch("type", nil) == "tool_calls"
+          tool_calls = result.fetch("tool_calls", []).map do |tc|
+            {
+              id: tc.fetch("id"),
+              name: tc.fetch("name"),
+              input: tc.fetch("input", {}),
+              requires_confirmation: tc.fetch("requires_confirmation", false)
+            }
+          end
+
+          formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
+
+          process_tool_loop(tool_calls, formatter)
+        else
+          print "rubyn> "
+          formatter.print_content(result.dig("response") || result.dig("content") || "")
+          formatter.newline
+          formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
+        end
+      end
+
+      def process_tool_loop(tool_calls, formatter, round: 0)
+        if round >= MAX_TOOL_ROUNDS
+          formatter.warning("Maximum tool rounds (#{MAX_TOOL_ROUNDS}) reached. Stopping.")
+          return
+        end
+
+        results = execute_tool_calls(tool_calls, formatter)
+
+        begin
+          result = Rubyn.api_client.submit_tool_results(
+            conversation_id: @conversation_id,
+            tool_results: results,
+            project_token: @project_token
+          )
+
+          @conversation_id ||= result["conversation_id"]
+
+          display_agent_result(result, formatter)
+        rescue Rubyn::AuthenticationError => e
+          formatter.error("Authentication failed: #{e.message}")
+        rescue Rubyn::APIError => e
+          formatter.error(e.message)
+        end
+      end
+
+      def execute_tool_calls(tool_calls, formatter)
+        tool_calls.map do |tc|
+          formatter.info("Tool: #{tc[:name]}(#{format_tool_params(tc[:input])})")
+
+          result = @executor.execute(
+            tc[:name],
+            tc[:input],
+            server_requires_confirmation: tc[:requires_confirmation]
+          )
+
+          if result[:success]
+            Rubyn::Output::Formatter.success("#{tc[:name]} completed")
+          elsif result[:error] == "denied_by_user"
+            Rubyn::Output::Formatter.warning("#{tc[:name]} denied by user")
+          else
+            Rubyn::Output::Formatter.error("#{tc[:name]}: #{result[:error]}")
+          end
+
+          { tool_call_id: tc[:id], result: result.is_a?(Hash) ? result.to_json : result }
+        end
+      end
+
+      def format_tool_params(params)
+        return "" unless params.is_a?(Hash)
+
+        params.map do |k, v|
+          val = v.is_a?(String) && v.length > MAX_PARAM_DISPLAY_LENGTH ? "#{v[0..MAX_PARAM_DISPLAY_LENGTH - 3]}..." : v
+          "#{k}: #{val}"
+        end.join(", ")
+      end
+
+      # Override base to use larger context limit for agent
+      def build_context_files(relative_path)
+        resolver = Rubyn::Context::FileResolver.new
+        related = resolver.resolve(relative_path)
+        builder = Rubyn::Context::ContextBuilder.new(Dir.pwd, max_bytes: Rubyn::Context::ContextBuilder::AGENT_MAX_CONTEXT_BYTES)
+        context = builder.build(relative_path, related)
+        context.reject { |path, _| path == relative_path }
+               .map { |path, content| { file_path: path, code: content } }
+      end
+
+      def extract_file_context(input)
+        files = input.scan(/@(\S+)/).flatten.select { |file| File.exist?(file) }
+        return [] if files.empty?
+
+        # Resolve dependencies for each attached file so the agent
+        # has full context and won't break related code during refactors
+        all_files = Set.new(files)
+        files.each do |file|
+          relative = relative_to_project(file)
+          related = build_context_files(relative)
+          related.each { |ctx| all_files << ctx[:file_path] }
+        end
+
+        all_files.to_a
+      end
+
+      def show_credits(formatter)
+        result = Rubyn.api_client.get_balance
+        formatter.info("Balance: #{result["balance"]} credits")
+        formatter.info("Plan: #{result["plan"]}")
+      rescue Rubyn::Error => e
+        formatter.error(e.message)
+      end
+    end
+  end
+end

data/lib/rubyn/commands/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Base
+      private
+
+      # Full check: credentials + project config (used by most commands)
+      def ensure_configured!
+        return if Rubyn::Config::Credentials.exists? && Rubyn::Config::ProjectConfig.exists?
+
+        Rubyn::Output::Formatter.error("Not configured. Run `rubyn init` first.")
+        raise Rubyn::ConfigurationError, "Not configured"
+      end
+
+      # Auto-index codebase if user has Pro/Lifetime but hasn't indexed yet
+      # def auto_index_if_needed!
+      #   result = Rubyn.api_client.verify_auth
+      #   return unless result.dig("user", "needs_indexing")
+      #
+      #   formatter = Rubyn::Output::Formatter
+      #   formatter.info("Pro feature unlocked — indexing your codebase for enhanced context...")
+      #   formatter.newline
+      #
+      #   indexer = Rubyn::Context::CodebaseIndexer.new
+      #   indexer.index
+      #   formatter.success("Codebase indexed! Your AI commands now include project context.")
+      #   formatter.newline
+      # rescue Rubyn::Error => e
+      #   Rubyn::Output::Formatter.warning("Auto-indexing skipped: #{e.message}")
+      # end
+      def auto_index_if_needed!; end
+
+      # Credentials-only check (used by usage command)
+      def ensure_credentials!
+        return if Rubyn::Config::Credentials.exists?
+
+        Rubyn::Output::Formatter.error("Not configured. Run `rubyn init` first.")
+        raise Rubyn::ConfigurationError, "Not configured"
+      end
+
+      def relative_to_project(file)
+        File.expand_path(file).sub("#{Dir.pwd}/", "")
+      end
+
+      def build_context_files(relative_path)
+        resolver = Rubyn::Context::FileResolver.new
+        related = resolver.resolve(relative_path)
+        builder = Rubyn::Context::ContextBuilder.new
+        context = builder.build(relative_path, related)
+        context.reject { |path, _| path == relative_path }
+               .map { |path, content| { file_path: path, code: content } }
+      end
+
+      def project_token
+        Rubyn::Config::ProjectConfig.project_token
+      end
+    end
+  end
+end

data/lib/rubyn/commands/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Config
+      VALID_KEYS = %w[default_model auto_apply output_format].freeze
+
+      def execute(key = nil, value = nil)
+        formatter = Output::Formatter
+
+        if key.nil?
+          display_all(formatter)
+        elsif value.nil?
+          display_key(formatter, key)
+        else
+          set_key(formatter, key, value)
+        end
+      end
+
+      private
+
+      def display_all(formatter)
+        formatter.header("Rubyn Configuration")
+        Rubyn::Config::Settings.all.each do |k, v|
+          formatter.info("#{k}: #{v}")
+        end
+      end
+
+      def display_key(formatter, key)
+        value = Rubyn::Config::Settings.get(key)
+        if value.nil?
+          formatter.warning("Unknown key: #{key}")
+          formatter.info("Valid keys: #{VALID_KEYS.join(", ")}")
+        else
+          formatter.info("#{key}: #{value}")
+        end
+      end
+
+      def set_key(formatter, key, value)
+        unless VALID_KEYS.include?(key)
+          formatter.error("Invalid key: #{key}")
+          formatter.info("Valid keys: #{VALID_KEYS.join(", ")}")
+          return
+        end
+
+        Rubyn::Config::Settings.set(key, value)
+        formatter.success("#{key} set to #{value}")
+      end
+    end
+  end
+end

data/lib/rubyn/commands/dashboard.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Dashboard
+      DEFAULT_PORT = 9292
+
+      def execute
+        formatter = Rubyn::Output::Formatter
+
+        if rails_project_with_engine?
+          formatter.info("Dashboard available at: http://localhost:3000/rubyn")
+          formatter.info("Start your Rails server with `rails s` to access.")
+        else
+          start_standalone_dashboard(formatter)
+        end
+      end
+
+      private
+
+      def rails_project_with_engine?
+        routes_file = File.join(Dir.pwd, "config", "routes.rb")
+        return false unless File.exist?(routes_file)
+
+        File.read(routes_file).include?("Rubyn::Engine")
+      end
+
+      def start_standalone_dashboard(formatter)
+        formatter.info("Starting standalone dashboard...")
+        formatter.info("Dashboard: http://localhost:#{DEFAULT_PORT}/rubyn")
+
+        require "sinatra/base"
+
+        port = DEFAULT_PORT
+        app = Class.new(Sinatra::Base) do
+          set :port, port
+          set :bind, "0.0.0.0"
+
+          get "/rubyn" do
+            content_type :html
+            build_dashboard_html
+          end
+
+          get "/rubyn/health" do
+            content_type :json
+            { status: "ok", version: Rubyn::VERSION }.to_json
+          end
+
+          helpers do
+            def build_dashboard_html
+              <<~HTML
+                <!DOCTYPE html>
+                <html>
+                <head>
+                  <title>Rubyn Dashboard</title>
+                  <style>
+                    body { font-family: system-ui; background: #1a1a2e; color: #e0e0e0; margin: 0; padding: 2rem; }
+                    h1 { color: #e94560; }
+                    .card { background: #16213e; border-radius: 8px; padding: 1.5rem; margin: 1rem 0; }
+                    .info { color: #a0a0a0; }
+                  </style>
+                </head>
+                <body>
+                  <h1>Rubyn Dashboard</h1>
+                  <div class="card">
+                    <h2>Standalone Mode</h2>
+                    <p class="info">Mount the Rubyn engine in your Rails app for the full dashboard experience.</p>
+                    <p class="info">Run: <code>rails generate rubyn:install</code></p>
+                  </div>
+                  <div class="card">
+                    <h2>Version</h2>
+                    <p>#{Rubyn::VERSION}</p>
+                  </div>
+                </body>
+                </html>
+              HTML
+            end
+          end
+        end
+
+        app.run!
+      end
+    end
+  end
+end

data/lib/rubyn/commands/index.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubyn
+  module Commands
+    class Index < Base
+      PROGRESS_BAR_WIDTH = 30
+      SUMMARY_BOX_WIDTH = 44
+
+      def execute(force: false)
+        formatter = Rubyn::Output::Formatter
+        pastel = Pastel.new
+        ensure_configured!
+
+        formatter.header("Codebase Analysis")
+        formatter.newline
+
+        indexer = Rubyn::Context::CodebaseIndexer.new
+        chunk_bar = nil
+        upload_bar = nil
+
+        result = indexer.index(force: force) do |progress|
+          case progress[:phase]
+          when :scan
+            formatter.info(progress[:message])
+            formatter.newline
+          when :chunk
+            if chunk_bar.nil?
+              chunk_bar = TTY::Spinner::Multi.new("[:spinner] Chunking files")
+              @file_spinners = {}
+            end
+            render_file_progress(chunk_bar, progress, pastel)
+          when :upload
+            chunk_bar&.success
+            formatter.newline
+            formatter.info(progress[:message])
+          when :upload_batch
+            if upload_bar.nil?
+              upload_bar = TTY::Spinner.new(
+                "[:spinner] Uploading batch :current/:total",
+                format: :dots
+              )
+              upload_bar.auto_spin
+            end
+            upload_bar.update(current: progress[:current], total: progress[:total])
+          when :complete
+            upload_bar&.success("Done!")
+            formatter.newline
+            formatter.success(progress[:message])
+          end
+        end
+
+        formatter.newline
+        render_summary(formatter, pastel, result)
+      rescue Rubyn::Error => e
+        formatter.error(e.message)
+      end
+
+      private
+
+      def render_file_progress(_multi, progress, pastel)
+        pct = ((progress[:current].to_f / progress[:total]) * 100).round
+        filled = (PROGRESS_BAR_WIDTH * progress[:current].to_f / progress[:total]).round
+        empty = PROGRESS_BAR_WIDTH - filled
+
+        bar = pastel.green("#" * filled) + pastel.dim("." * empty)
+        file_name = truncate_path(progress[:file], 40)
+
+        print "\r  #{bar} #{pct}%  #{pastel.dim(file_name)}#{" " * 20}"
+        puts if progress[:current] == progress[:total]
+      end
+
+      def render_summary(_formatter, pastel, result)
+        return if result.nil?
+
+        border = pastel.dim("+#{"-" * (SUMMARY_BOX_WIDTH - 2)}+")
+        spacer = pastel.dim("|") + (" " * (SUMMARY_BOX_WIDTH - 2)) + pastel.dim("|")
+
+        puts border
+        puts spacer
+        puts row(pastel, "  Files analysed", result[:indexed].to_s, SUMMARY_BOX_WIDTH)
+        puts row(pastel, "  Files skipped", result[:skipped].to_s, SUMMARY_BOX_WIDTH)
+        puts row(pastel, "  Chunks created", result[:chunks].to_s, SUMMARY_BOX_WIDTH)
+        puts spacer
+        puts border
+      end
+
+      def row(pastel, label, value, width)
+        content = "#{label}#{" " * (width - 4 - label.length - value.length)}#{pastel.bold(value)}"
+        "#{pastel.dim("|")} #{content} #{pastel.dim("|")}"
+      end
+
+      def truncate_path(path, max)
+        return path if path.length <= max
+
+        "...#{path[-(max - 3)..]}"
+      end
+    end
+  end
+end

data/lib/rubyn/commands/init.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "tty-prompt"
+
+module Rubyn
+  module Commands
+    class Init
+      PROJECT_TOKEN_PREFIX = "rprj_".freeze
+      PROJECT_TOKEN_HEX_LENGTH = 12
+      TOKEN_PREVIEW_LENGTH = 9
+
+      def execute
+        formatter = Rubyn::Output::Formatter
+        prompt = TTY::Prompt.new
+
+        formatter.header("Rubyn Init")
+
+        if Rubyn::Config::ProjectConfig.exists?
+          join_existing_project(formatter)
+          return
+        end
+
+        api_key = resolve_api_key(formatter, prompt)
+        return unless api_key
+
+        verify_api_key(formatter, api_key)
+
+        metadata = scan_project(formatter)
+        project_token = "#{PROJECT_TOKEN_PREFIX}#{SecureRandom.hex(PROJECT_TOKEN_HEX_LENGTH)}"
+        result = sync_project(formatter, metadata, project_token)
+
+        write_project_config(result)
+        # offer_indexing(formatter, prompt, result)
+        display_summary(formatter, metadata, result)
+      end
+
+      private
+
+      def join_existing_project(formatter)
+        project_token = Rubyn::Config::ProjectConfig.project_token
+        formatter.info("Existing project detected. Joining with token: #{project_token[0..TOKEN_PREVIEW_LENGTH - 1]}...")
+
+        spinner = Rubyn::Output::Spinner.new
+        spinner.start("Joining project...")
+
+        begin
+          result = Rubyn.api_client.join_project(project_token: project_token)
+          spinner.stop_success("Joined!")
+          formatter.success("Successfully joined project. Project ID: #{result.dig("project", "id")}")
+        rescue Rubyn::Error => e
+          spinner.stop_error("Failed")
+          formatter.error("Could not join project: #{e.message}")
+        end
+      end
+
+      def resolve_api_key(formatter, prompt)
+        if Rubyn::Config::Credentials.exists?
+          formatter.info("API key found in credentials")
+          return Rubyn::Config::Credentials.api_key
+        end
+
+        if ENV["RUBYN_API_KEY"]
+          formatter.info("Using RUBYN_API_KEY from environment")
+          return ENV["RUBYN_API_KEY"]
+        end
+
+        api_key = prompt.ask("Enter your Rubyn API key:") do |q|
+          q.required true
+          q.validate(/\Ark_/, "API key should start with 'rk_'")
+        end
+
+        Rubyn::Config::Credentials.store(api_key: api_key)
+        formatter.success("API key saved to ~/.rubyn/credentials")
+        api_key
+      end
+
+      def verify_api_key(formatter, api_key)
+        spinner = Rubyn::Output::Spinner.new
+        spinner.start("Verifying API key...")
+
+        Rubyn.configuration.api_key = api_key
+        result = Rubyn.api_client.verify_auth
+        spinner.stop_success("Verified!")
+
+        formatter.info("Authenticated as: #{result.dig("user", "email")}")
+        formatter.info("Plan: #{result.dig("user", "plan")}")
+      rescue Rubyn::AuthenticationError
+        spinner.stop_error("Invalid!")
+        formatter.error("API key is invalid. Get your key at https://rubyn.dev/settings")
+        raise
+      end
+
+      def scan_project(_formatter)
+        spinner = Rubyn::Output::Spinner.new
+        spinner.start("Scanning project...")
+        scanner = Rubyn::Context::ProjectScanner.new
+        metadata = scanner.scan
+        spinner.stop_success("Scanned!")
+        metadata
+      end
+
+      def sync_project(_formatter, metadata, project_token)
+        spinner = Rubyn::Output::Spinner.new
+        spinner.start("Syncing project with Rubyn...")
+        result = Rubyn.api_client.sync_project(metadata: metadata, project_token: project_token)
+        spinner.stop_success("Synced!")
+        result
+      end
+
+      def write_project_config(result)
+        project = result.fetch("project")
+        Rubyn::Config::ProjectConfig.write({
+                                             "project_token" => project.fetch("project_token"),
+                                             "project_id" => project.fetch("id")
+                                           })
+        ensure_gitignore
+      end
+
+      def ensure_gitignore
+        gitignore_path = File.join(Dir.pwd, ".gitignore")
+        return unless File.exist?(gitignore_path)
+
+        content = File.read(gitignore_path)
+        return if content.match?(/^\/?\.rubyn\/?$/)
+
+        File.open(gitignore_path, "a") do |f|
+          f.puts unless content.end_with?("\n")
+          f.puts "\n# Rubyn project config"
+          f.puts ".rubyn/"
+        end
+      end
+
+      # def offer_indexing(formatter, prompt, _result)
+      #   return unless prompt.yes?("Analyse your codebase for enhanced context? (Pro feature)")
+      #
+      #   spinner = Rubyn::Output::Spinner.new
+      #   spinner.start("Analysing codebase...")
+      #   indexer = Rubyn::Context::CodebaseIndexer.new
+      #   stats = indexer.index
+      #   spinner.stop_success("Done!")
+      #   formatter.info("Analysed #{stats[:indexed]} files (#{stats[:skipped]} unchanged)")
+      # rescue Rubyn::AuthenticationError
+      #   spinner&.stop_error("Skipped")
+      #   formatter.warning("Codebase analysis requires a Pro plan. Skipping.")
+      # rescue Rubyn::APIError => e
+      #   spinner&.stop_error("Failed")
+      #   formatter.error("Could not analyse codebase: #{e.message}")
+      # end
+
+      def display_summary(formatter, metadata, result)
+        formatter.newline
+        formatter.header("Project Summary")
+        formatter.info("Project: #{metadata[:project_name]}")
+        formatter.info("Type: #{metadata[:project_type]}")
+        formatter.info("Ruby: #{metadata[:ruby_version] || "not detected"}")
+        formatter.info("Rails: #{metadata[:rails_version] || "N/A"}")
+        formatter.info("Tests: #{metadata[:test_framework]}")
+        formatter.info("Credits: N/A")
+        formatter.newline
+        formatter.info("Run `rubyn refactor <file>` to get started.")
+        formatter.info("Or visit http://localhost:3000/rubyn for the dashboard.")
+      end
+    end
+  end
+end