console_agent 0.1.0 → 0.3.0

data/lib/console_agent/storage/file_storage.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require 'console_agent/storage/base'
+
+module ConsoleAgent
+  module Storage
+    class FileStorage < Base
+      attr_reader :root_path
+
+      def initialize(root_path = nil)
+        @root_path = root_path || default_root
+      end
+
+      def read(key)
+        path = full_path(key)
+        return nil unless File.exist?(path)
+        File.read(path)
+      end
+
+      def write(key, content)
+        path = full_path(key)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot write #{key}: #{e.message}"
+      end
+
+      def list(pattern)
+        Dir.glob(File.join(@root_path, pattern)).sort.map do |path|
+          path.sub("#{@root_path}/", '')
+        end
+      end
+
+      def exists?(key)
+        File.exist?(full_path(key))
+      end
+
+      def delete(key)
+        path = full_path(key)
+        return false unless File.exist?(path)
+        File.delete(path)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot delete #{key}: #{e.message}"
+      end
+
+      private
+
+      def full_path(key)
+        sanitized = key.gsub('..', '').gsub(%r{\A/+}, '')
+        File.join(@root_path, sanitized)
+      end
+
+      def default_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          File.join(Rails.root.to_s, '.console_agent')
+        else
+          File.join(Dir.pwd, '.console_agent')
+        end
+      end
+    end
+  end
+end

data/lib/console_agent/tools/memory_tools.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+module ConsoleAgent
+  module Tools
+    class MemoryTools
+      MEMORIES_DIR = 'memories'
+
+      def initialize(storage = nil)
+        @storage = storage || ConsoleAgent.storage
+      end
+
+      def save_memory(name:, description:, tags: [])
+        key = memory_key(name)
+        existing = load_memory(key)
+
+        frontmatter = {
+          'name' => name,
+          'tags' => Array(tags).empty? && existing ? (existing['tags'] || []) : Array(tags),
+          'created_at' => existing ? existing['created_at'] : Time.now.utc.iso8601
+        }
+        frontmatter['updated_at'] = Time.now.utc.iso8601 if existing
+
+        content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{description}\n"
+        @storage.write(key, content)
+
+        path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
+        if existing
+          "Memory updated: \"#{name}\" (#{path})"
+        else
+          "Memory saved: \"#{name}\" (#{path})"
+        end
+      rescue Storage::StorageError => e
+        "FAILED to save (#{e.message}). Add this manually to .console_agent/#{key}:\n" \
+        "---\nname: #{name}\ntags: #{Array(tags).inspect}\n---\n\n#{description}"
+      end
+
+      def delete_memory(name:)
+        key = memory_key(name)
+        unless @storage.exists?(key)
+          # Try to find by name match across all memory files
+          found_key = find_memory_key_by_name(name)
+          return "No memory found: \"#{name}\"" unless found_key
+          key = found_key
+        end
+
+        memory = load_memory(key)
+        @storage.delete(key)
+        "Memory deleted: \"#{memory ? memory['name'] : name}\""
+      rescue Storage::StorageError => e
+        "FAILED to delete memory (#{e.message})."
+      end
+
+      def recall_memories(query: nil, tag: nil)
+        memories = load_all_memories
+        return "No memories stored yet." if memories.empty?
+
+        results = memories
+        if tag && !tag.empty?
+          results = results.select { |m|
+            Array(m['tags']).any? { |t| t.downcase.include?(tag.downcase) }
+          }
+        end
+        if query && !query.empty?
+          q = query.downcase
+          results = results.select { |m|
+            m['name'].to_s.downcase.include?(q) ||
+            m['description'].to_s.downcase.include?(q) ||
+            Array(m['tags']).any? { |t| t.downcase.include?(q) }
+          }
+        end
+
+        return "No memories matching your search." if results.empty?
+
+        results.map { |m|
+          line = "**#{m['name']}**\n#{m['description']}"
+          line += "\nTags: #{m['tags'].join(', ')}" if m['tags'] && !m['tags'].empty?
+          line
+        }.join("\n\n")
+      end
+
+      def memory_summaries
+        memories = load_all_memories
+        return nil if memories.empty?
+
+        memories.map { |m|
+          tags = Array(m['tags'])
+          tag_str = tags.empty? ? '' : " [#{tags.join(', ')}]"
+          "- #{m['name']}#{tag_str}"
+        }
+      end
+
+      private
+
+      def memory_key(name)
+        slug = name.downcase.strip
+          .gsub(/[^a-z0-9\s-]/, '')
+          .gsub(/[\s]+/, '-')
+          .gsub(/-+/, '-')
+          .sub(/^-/, '').sub(/-$/, '')
+        "#{MEMORIES_DIR}/#{slug}.md"
+      end
+
+      def load_memory(key)
+        content = @storage.read(key)
+        return nil if content.nil? || content.strip.empty?
+        parse_memory(content)
+      rescue => e
+        ConsoleAgent.logger.warn("ConsoleAgent: failed to load memory #{key}: #{e.message}")
+        nil
+      end
+
+      def load_all_memories
+        keys = @storage.list("#{MEMORIES_DIR}/*.md")
+        keys.map { |key| load_memory(key) }.compact
+      rescue => e
+        ConsoleAgent.logger.warn("ConsoleAgent: failed to load memories: #{e.message}")
+        []
+      end
+
+      def parse_memory(content)
+        return nil unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
+        frontmatter = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
+        description = $2.strip
+        frontmatter.merge('description' => description)
+      end
+
+      def find_memory_key_by_name(name)
+        keys = @storage.list("#{MEMORIES_DIR}/*.md")
+        keys.find do |key|
+          memory = load_memory(key)
+          memory && memory['name'].to_s.downcase == name.downcase
+        end
+      end
+    end
+  end
+end

data/lib/console_agent/tools/registry.rb

@@ -5,12 +5,22 @@ module ConsoleAgent
     class Registry
       attr_reader :definitions
 
-      def initialize
+      # Tools that should never be cached (side effects or user interaction)
+      NO_CACHE = %w[ask_user save_memory delete_memory execute_plan].freeze
+
+      def initialize(executor: nil)
+        @executor = executor
         @definitions = []
         @handlers = {}
+        @cache = {}
+        @last_cached = false
         register_all
       end
 
+      def last_cached?
+        @last_cached
+      end
+
       def execute(tool_name, arguments = {})
         handler = @handlers[tool_name]
         unless handler
@@ -27,7 +37,18 @@ module ConsoleAgent
                  arguments || {}
                end
 
-        handler.call(args)
+        unless NO_CACHE.include?(tool_name)
+          cache_key = [tool_name, args].hash
+          if @cache.key?(cache_key)
+            @last_cached = true
+            return @cache[cache_key]
+          end
+        end
+
+        @last_cached = false
+        result = handler.call(args)
+        @cache[[tool_name, args].hash] = result unless NO_CACHE.include?(tool_name)
+        result
       rescue => e
         "Error executing #{tool_name}: #{e.message}"
       end
@@ -158,6 +179,211 @@ module ConsoleAgent
           },
           handler: ->(args) { ask_user(args['question']) }
         )
+
+        register_memory_tools
+        register_execute_plan
+      end
+
+      def register_memory_tools
+        return unless ConsoleAgent.configuration.memories_enabled
+
+        require 'console_agent/tools/memory_tools'
+        memory = MemoryTools.new
+
+        register(
+          name: 'save_memory',
+          description: 'Save a fact or pattern you learned about this codebase for future sessions. Use after discovering how something works (e.g. sharding, auth, custom business logic).',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Short name for this memory (e.g. "Sharding architecture")' },
+              'description' => { 'type' => 'string', 'description' => 'Detailed description of what you learned' },
+              'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags (e.g. ["database", "sharding"])' }
+            },
+            'required' => ['name', 'description']
+          },
+          handler: ->(args) {
+            memory.save_memory(name: args['name'], description: args['description'], tags: args['tags'] || [])
+          }
+        )
+
+        register(
+          name: 'delete_memory',
+          description: 'Delete a memory by name.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The memory name to delete (e.g. "Sharding architecture")' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) { memory.delete_memory(name: args['name']) }
+        )
+
+        register(
+          name: 'recall_memories',
+          description: 'Search your saved memories about this codebase. Call with no args to list all, or pass a query/tag to filter.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'query' => { 'type' => 'string', 'description' => 'Search term to filter by name, description, or tags' },
+              'tag' => { 'type' => 'string', 'description' => 'Filter by a specific tag' }
+            }
+          },
+          handler: ->(args) { memory.recall_memories(query: args['query'], tag: args['tag']) }
+        )
+      end
+
+      def register_execute_plan
+        return unless @executor
+
+        register(
+          name: 'execute_plan',
+          description: 'Execute a multi-step plan. Each step has a description and Ruby code. The plan is shown to the user for approval, then each step is executed in order. After each step executes, its return value is stored as step1, step2, etc. Use these variables in later steps to reference earlier results (e.g. `token = step1`).',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'steps' => {
+                'type' => 'array',
+                'description' => 'Ordered list of steps to execute',
+                'items' => {
+                  'type' => 'object',
+                  'properties' => {
+                    'description' => { 'type' => 'string', 'description' => 'What this step does' },
+                    'code' => { 'type' => 'string', 'description' => 'Ruby code to execute' }
+                  },
+                  'required' => %w[description code]
+                }
+              }
+            },
+            'required' => ['steps']
+          },
+          handler: ->(args) { execute_plan(args['steps'] || []) }
+        )
+      end
+
+      def execute_plan(steps)
+        return 'No steps provided.' if steps.nil? || steps.empty?
+
+        auto = ConsoleAgent.configuration.auto_execute
+
+        # Display full plan
+        $stdout.puts
+        $stdout.puts "\e[36m  Plan (#{steps.length} steps):\e[0m"
+        steps.each_with_index do |step, i|
+          $stdout.puts "\e[36m  #{i + 1}. #{step['description']}\e[0m"
+          $stdout.puts highlight_plan_code(step['code'])
+        end
+        $stdout.puts
+
+        # Ask for plan approval (unless auto-execute)
+        skip_confirmations = auto
+        unless auto
+          $stdout.print "\e[33m  Accept plan? [y/N/a(uto)] \e[0m"
+          answer = $stdin.gets.to_s.strip.downcase
+          case answer
+          when 'a', 'auto'
+            skip_confirmations = true
+          when 'y', 'yes'
+            # proceed with per-step confirmation
+          else
+            $stdout.puts "\e[33m  Plan declined.\e[0m"
+            feedback = ask_feedback("What would you like changed?")
+            return "User declined the plan. Feedback: #{feedback}"
+          end
+        end
+
+        # Execute steps one by one
+        results = []
+        steps.each_with_index do |step, i|
+          $stdout.puts
+          $stdout.puts "\e[36m  Step #{i + 1}/#{steps.length}: #{step['description']}\e[0m"
+          $stdout.puts "\e[33m  # Code:\e[0m"
+          $stdout.puts highlight_plan_code(step['code'])
+
+          # Per-step confirmation (unless auto-execute or plan-level auto)
+          unless skip_confirmations
+            $stdout.print "\e[33m  Run? [y/N/edit] \e[0m"
+            step_answer = $stdin.gets.to_s.strip.downcase
+
+            case step_answer
+            when 'e', 'edit'
+              edited = edit_step_code(step['code'])
+              if edited && edited != step['code']
+                $stdout.puts "\e[33m  # Edited code:\e[0m"
+                $stdout.puts highlight_plan_code(edited)
+                $stdout.print "\e[33m  Run edited code? [y/N] \e[0m"
+                confirm = $stdin.gets.to_s.strip.downcase
+                unless confirm == 'y' || confirm == 'yes'
+                  feedback = ask_feedback("What would you like changed?")
+                  results << "Step #{i + 1}: User declined after edit. Feedback: #{feedback}"
+                  break
+                end
+                step['code'] = edited
+              end
+            when 'y', 'yes'
+              # proceed
+            else
+              feedback = ask_feedback("What would you like changed?")
+              results << "Step #{i + 1}: User declined. Feedback: #{feedback}"
+              break
+            end
+          end
+
+          exec_result = @executor.execute(step['code'])
+          # Make result available as step1, step2, etc. for subsequent steps
+          @executor.binding_context.local_variable_set(:"step#{i + 1}", exec_result)
+          output = @executor.last_output
+
+          step_report = "Step #{i + 1} (#{step['description']}):\n"
+          if output && !output.strip.empty?
+            step_report += "Output: #{output.strip}\n"
+          end
+          step_report += "Return value: #{exec_result.inspect}"
+          results << step_report
+        end
+
+        results.join("\n\n")
+      end
+
+      def highlight_plan_code(code)
+        if coderay_available?
+          CodeRay.scan(code, :ruby).terminal.gsub(/^/, '     ')
+        else
+          code.split("\n").map { |l| "     \e[37m#{l}\e[0m" }.join("\n")
+        end
+      end
+
+      def edit_step_code(code)
+        require 'tempfile'
+        editor = ENV['EDITOR'] || 'vi'
+        tmpfile = Tempfile.new(['console_agent_step', '.rb'])
+        tmpfile.write(code)
+        tmpfile.flush
+        system("#{editor} #{tmpfile.path}")
+        File.read(tmpfile.path).strip
+      rescue => e
+        $stderr.puts "\e[31m  Editor error: #{e.message}\e[0m"
+        code
+      ensure
+        tmpfile.close! if tmpfile
+      end
+
+      def coderay_available?
+        return @coderay_available unless @coderay_available.nil?
+        @coderay_available = begin
+          require 'coderay'
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      def ask_feedback(prompt)
+        $stdout.print "\e[36m  #{prompt} > \e[0m"
+        feedback = $stdin.gets
+        return '(no feedback provided)' if feedback.nil?
+        feedback.strip.empty? ? '(no feedback provided)' : feedback.strip
       end
 
       def ask_user(question)

data/lib/console_agent/version.rb

@@ -1,3 +1,3 @@
 module ConsoleAgent
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/console_agent.rb

@@ -13,6 +13,23 @@ module ConsoleAgent
 
     def reset_configuration!
       @configuration = Configuration.new
+      reset_storage!
+    end
+
+    def storage
+      @storage ||= begin
+        adapter = configuration.storage_adapter
+        if adapter
+          adapter
+        else
+          require 'console_agent/storage/file_storage'
+          Storage::FileStorage.new
+        end
+      end
+    end
+
+    def reset_storage!
+      @storage = nil
     end
 
     def logger
@@ -28,6 +45,14 @@ module ConsoleAgent
       @logger = log
     end
 
+    def current_user
+      @current_user
+    end
+
+    def current_user=(name)
+      @current_user = name
+    end
+
     def status
       c = configuration
       key = c.resolved_api_key
@@ -42,17 +67,132 @@ module ConsoleAgent
       lines << "  Provider:       #{c.provider}"
       lines << "  Model:          #{c.resolved_model}"
       lines << "  API key:        #{masked_key}"
-      lines << "  Context mode:   #{c.context_mode}"
       lines << "  Max tokens:     #{c.max_tokens}"
       lines << "  Temperature:    #{c.temperature}"
       lines << "  Timeout:        #{c.timeout}s"
-      lines << "  Max tool rounds:#{c.max_tool_rounds}" if c.context_mode == :smart
+      lines << "  Max tool rounds:#{c.max_tool_rounds}"
       lines << "  Auto-execute:   #{c.auto_execute}"
+      lines << "  Memories:       #{c.memories_enabled}"
+      lines << "  Session logging:#{session_table_status}"
       lines << "  Debug:          #{c.debug}"
       $stdout.puts lines.join("\n")
       nil
     end
+
+    def setup!
+      conn = session_connection
+      table = 'console_agent_sessions'
+
+      if conn.table_exists?(table)
+        $stdout.puts "\e[32mConsoleAgent: #{table} already exists. Run ConsoleAgent.teardown! first to recreate.\e[0m"
+      else
+        conn.create_table(table) do |t|
+          t.text    :query,         null: false
+          t.text    :conversation,  null: false
+          t.integer :input_tokens,  default: 0
+          t.integer :output_tokens, default: 0
+          t.string  :user_name,     limit: 255
+          t.string  :mode,          limit: 20, null: false
+          t.text    :code_executed
+          t.text    :code_output
+          t.text    :code_result
+          t.text    :console_output
+          t.boolean :executed,      default: false
+          t.string  :provider,      limit: 50
+          t.string  :model,         limit: 100
+          t.string  :name,          limit: 255
+          t.integer :duration_ms
+          t.datetime :created_at,   null: false
+        end
+
+        conn.add_index(table, :created_at)
+        conn.add_index(table, :user_name)
+        conn.add_index(table, :name)
+
+        $stdout.puts "\e[32mConsoleAgent: created #{table} table.\e[0m"
+      end
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent setup failed: #{e.class}: #{e.message}\e[0m"
+    end
+
+    def migrate!
+      conn = session_connection
+      table = 'console_agent_sessions'
+
+      unless conn.table_exists?(table)
+        $stderr.puts "\e[33mConsoleAgent: #{table} does not exist. Run ConsoleAgent.setup! first.\e[0m"
+        return
+      end
+
+      migrations = []
+
+      unless conn.column_exists?(table, :name)
+        conn.add_column(table, :name, :string, limit: 255)
+        conn.add_index(table, :name) unless conn.index_exists?(table, :name)
+        migrations << 'name'
+      end
+
+      if migrations.empty?
+        $stdout.puts "\e[32mConsoleAgent: #{table} is up to date.\e[0m"
+      else
+        $stdout.puts "\e[32mConsoleAgent: added columns: #{migrations.join(', ')}.\e[0m"
+      end
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent migrate failed: #{e.class}: #{e.message}\e[0m"
+    end
+
+    def teardown!
+      conn = session_connection
+      table = 'console_agent_sessions'
+
+      unless conn.table_exists?(table)
+        $stdout.puts "\e[33mConsoleAgent: #{table} does not exist, nothing to remove.\e[0m"
+        return
+      end
+
+      count = conn.select_value("SELECT COUNT(*) FROM #{conn.quote_table_name(table)}")
+      $stdout.print "\e[33mDrop #{table} (#{count} sessions)? [y/N] \e[0m"
+      answer = $stdin.gets.to_s.strip.downcase
+
+      unless answer == 'y' || answer == 'yes'
+        $stdout.puts "\e[33mCancelled.\e[0m"
+        return
+      end
+
+      conn.drop_table(table)
+      $stdout.puts "\e[32mConsoleAgent: dropped #{table}.\e[0m"
+    rescue => e
+      $stderr.puts "\e[31mConsoleAgent teardown failed: #{e.class}: #{e.message}\e[0m"
+    end
+
+    private
+
+    def session_table_status
+      return 'disabled' unless configuration.session_logging
+      conn = session_connection
+      if conn.table_exists?('console_agent_sessions')
+        count = conn.select_value("SELECT COUNT(*) FROM #{conn.quote_table_name('console_agent_sessions')}")
+        "\e[32m#{count} sessions\e[0m"
+      else
+        "\e[33mtable missing (run ConsoleAgent.setup!)\e[0m"
+      end
+    rescue
+      "\e[33munavailable\e[0m"
+    end
+
+    def session_connection
+      klass = configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        ActiveRecord::Base.connection
+      end
+    end
   end
 end
 
-require 'console_agent/railtie' if defined?(Rails::Railtie)
+if defined?(Rails::Railtie)
+  require 'console_agent/railtie'
+  require 'console_agent/engine'
+end

data/lib/generators/console_agent/templates/initializer.rb

@@ -17,12 +17,7 @@ ConsoleAgent.configure do |config|
   # Auto-execute generated code without confirmation (use with caution!)
   config.auto_execute = false
 
-  # Context mode:
-  #   :smart - (default) minimal system prompt, LLM uses tools to fetch schema/model/code details on demand
-  #   :full  - sends all schema, models, and routes in the system prompt every time
-  config.context_mode = :smart
-
-  # Max tool-use rounds per query in :smart mode (safety cap)
+  # Max tool-use rounds per query (safety cap)
   config.max_tool_rounds = 10
 
   # HTTP timeout in seconds
@@ -30,4 +25,17 @@ ConsoleAgent.configure do |config|
 
   # Debug mode: prints full API requests/responses and tool calls to stderr
   # config.debug = true
+
+  # Session logging: persist AI sessions to the database
+  # Run ConsoleAgent.setup! in the Rails console to create the table
+  config.session_logging = true
+
+  # Database connection for ConsoleAgent tables (default: ActiveRecord::Base)
+  # Set to a class that responds to .connection if tables live on a different DB
+  # config.connection_class = Sharding::CentralizedModel
+
+  # Admin UI credentials (mount ConsoleAgent::Engine => '/console_agent' in routes.rb)
+  # When nil, no authentication is required (convenient for development)
+  # config.admin_username = 'admin'
+  # config.admin_password = 'changeme'
 end