aia 0.9.13 → 0.9.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5d9ca1e0f36d50857345bcad1268359e8435c16ba2c159d68482c070de59207
-  data.tar.gz: 20e10d41131b850e7320613f0959d8c94589e48422bc5ba948954c614c094c12
+  metadata.gz: 91bd0c834c03dafa5c71d9d5e608db37ecd398c897e806361069aabee36d8abc
+  data.tar.gz: d275ec9393e55f3b39978fffd97a9eecf36021786ef579cdae0746488b0fe401
 SHA512:
-  metadata.gz: bb7913215b44a686db90c9e9e4a69a00024611c0a28f7f06da4290ad7781ef9685288845ea17f3c4180f74badf4d0829a462596a0280aed91354b6d54a36f975
-  data.tar.gz: 1701b67da9e0aa8afa4cd1815422989544c191e50a38f58205984b1d96033d4a6dea27fe1b9efceb9307b231848fd9cc6440bd83203a9b03dfa7c5dbee700fd2
+  metadata.gz: b2f00745bd78ffba8a434497946aa4a2116b7d0cfe805f8a5b132869af70e6698b490f8361a7589da875dc8d64a9869cd5c22b588347cabeefa10b0f8585e196
+  data.tar.gz: e4334b5fb5d25851aa3a1c29af391f82b6fc9ecbf1f6bc52edf999475e29b62ecf40395c246200f5ff525c1e0d8d3dd51330a4738d4b2b20f08594c9d0969431

data/.version

@@ -1 +1 @@
-0.9.13
+0.9.14

data/CHANGELOG.md

@@ -3,6 +3,50 @@
 
 ## Released
 
+### [0.9.14] 2025-09-19
+
+#### New Features
+- **NEW FEATURE**: Added `//checkpoint` directive to create named snapshots of conversation context
+- **NEW FEATURE**: Added `//restore` directive to restore context to a previous checkpoint
+- **NEW FEATURE**: Enhanced `//context` (and `//review`) directive to display checkpoint markers in conversation history
+- **NEW FEATURE**: Added `//cp` alias for checkpoint directive
+
+#### Improvements
+- **ENHANCEMENT**: Context manager now tracks checkpoint positions for better context visualization
+- **ENHANCEMENT**: Checkpoint system uses auto-incrementing integer names when no name is provided
+- **ENHANCEMENT**: Restore directive defaults to last checkpoint when no name specified
+- **ENHANCEMENT**: Clear context now also clears all checkpoints
+
+#### Bug Fixes
+- **BUG FIX**: Fixed `//help` directive that was showing empty list of directives
+- **BUG FIX**: Help directive now displays all directives from all registered modules
+- **BUG FIX**: Help directive now shows proper descriptions and aliases for all directives
+- **BUG FIX**: Help directive organizes directives by category for better readability
+
+#### Technical Changes
+- Enhanced ContextManager with checkpoint storage and restoration capabilities
+- Added checkpoint_positions method to track checkpoint locations in context
+- Refactored help directive to collect directives from all registered modules
+- Added comprehensive test coverage for checkpoint and restore functionality
+
+### [0.9.13] 2025-09-02
+#### New Features
+- **NEW FEATURE**: Added `--metrics` flag to show token counts for each model
+- **NEW FEATURE**: Added `--cost` flag to enable cost estimation for each model
+
+#### Improvements
+- **DEPENDENCY**: Removed versionaire dependency, simplifying version management
+- **ENHANCEMENT**: Improved test suite reliability and coverage
+- **ENHANCEMENT**: Updated Gemfile.lock with latest dependency versions
+
+#### Bug Fixes
+- **BUG FIX**: Fixed version handling issues by removing external versioning dependency
+
+#### Technical Changes
+- Simplified version management by removing versionaire gem
+- Enhanced test suite with improved assertions and coverage
+- Updated various gem dependencies to latest stable versions
+
 ### [0.9.12] 2025-08-28
 
 #### New Features

data/README.md

@@ -334,7 +334,9 @@ Directives are special commands in prompt files that begin with `//` and provide
 | Directive | Description | Example |
 |-----------|-------------|---------|
 | `//config` | Set configuration values | `//config model = gpt-4` |
-| `//context` | Show context for this conversation | `//context` |
+| `//context` | Show context for this conversation with checkpoint markers | `//context` |
+| `//checkpoint` | Create a named checkpoint of current context | `//checkpoint save_point` |
+| `//restore` | Restore context to a previous checkpoint | `//restore save_point` |
 | `//include` | Insert file contents | `//include path/to/file.txt` |
 | `//shell` | Execute shell commands | `//shell ls -la` |
 | `//robot` | Show the pet robot ASCII art w/versions | `//robot` |
@@ -346,7 +348,7 @@ Directives are special commands in prompt files that begin with `//` and provide
 | `//model` | Show current model configuration | `//model` |
 | `//available_models` | List available models | `//available_models` |
 | `//tools` | Show a list of available tools and their description | `//tools` |
-| `//review` | Review current context | `//review` |
+| `//review` | Review current context with checkpoint markers | `//review` |
 
 Directives can also be used in the interactive chat sessions.
 
@@ -379,6 +381,64 @@ Your prompt content here...
 Analyze the above information and provide insights.
 ```
 
+#### Context Management with Checkpoints
+
+AIA provides powerful context management capabilities in chat mode through checkpoint and restore directives:
+
+```bash
+# Create a checkpoint with automatic naming (1, 2, 3...)
+//checkpoint
+
+# Create a named checkpoint
+//checkpoint important_decision
+
+# Restore to the last checkpoint
+//restore
+
+# Restore to a specific checkpoint
+//restore important_decision
+
+# View context with checkpoint markers
+//context
+```
+
+**Example Chat Session:**
+```
+You: Tell me about Ruby programming
+AI: Ruby is a dynamic programming language...
+
+You: //checkpoint ruby_basics
+
+You: Now explain object-oriented programming
+AI: Object-oriented programming (OOP) is...
+
+You: //checkpoint oop_concepts
+
+You: Actually, let's go back to Ruby basics
+You: //restore ruby_basics
+
+You: //context
+=== Chat Context ===
+Total messages: 4
+Checkpoints: ruby_basics, oop_concepts
+
+1. [System]: You are a helpful assistant
+2. [User]: Tell me about Ruby programming
+3. [Assistant]: Ruby is a dynamic programming language...
+
+📍 [Checkpoint: ruby_basics]
+----------------------------------------
+4. [User]: Now explain object-oriented programming
+=== End of Context ===
+```
+
+**Key Features:**
+- **Auto-naming**: Checkpoints without names use incrementing integers (1, 2, 3...)
+- **Named checkpoints**: Use meaningful names like `//checkpoint before_refactor`
+- **Default restore**: `//restore` without a name restores to the last checkpoint
+- **Context visualization**: `//context` shows checkpoint markers in conversation history
+- **Clean slate**: `//clear` removes all context and checkpoints
+
 #### Custom Directive Examples
 
 You can extend AIA with custom directives by creating Ruby files that define new directive methods:

data/docs/directives-reference.md

@@ -271,21 +271,93 @@ Inserts a fun ASCII robot character for visual breaks in prompts.
 
 ## Context Management Directives
 
+### `//checkpoint`
+Create a named checkpoint of the current conversation context.
+
+**Syntax**: `//checkpoint [name]`
+
+**Examples**:
+```markdown
+//checkpoint                    # Auto-named checkpoint (1, 2, 3...)
+//checkpoint important_decision # Named checkpoint
+//checkpoint before_refactor    # Descriptive name
+```
+
+**Features**:
+- **Auto-naming**: If no name provided, uses incrementing integers (1, 2, 3...)
+- **Named checkpoints**: Use meaningful names for easy identification
+- **Deep copying**: Safely stores complete conversation state
+- **Chat mode only**: Only available during interactive chat sessions
+
+**Usage**:
+- `//checkpoint` - Create an auto-named checkpoint
+- `//checkpoint name` - Create a checkpoint with specific name
+
+**Aliases**: `//cp`
+
+### `//restore`
+Restore conversation context to a previously saved checkpoint.
+
+**Syntax**: `//restore [name]`
+
+**Examples**:
+```markdown
+//restore                      # Restore to last checkpoint
+//restore important_decision    # Restore to named checkpoint
+//restore 1                    # Restore to auto-named checkpoint
+```
+
+**Features**:
+- **Default behavior**: Without a name, restores to the most recent checkpoint
+- **Named restoration**: Restore to any previously saved checkpoint
+- **Context truncation**: Removes all messages added after the checkpoint
+- **Client refresh**: Automatically refreshes AI client context
+
+**Usage**:
+- `//restore` - Restore to the last checkpoint created
+- `//restore name` - Restore to a specific named checkpoint
+- Returns error message if checkpoint doesn't exist
+
 ### `//clear`
 Clear conversation context in chat mode.
 
 **Syntax**: `//clear`
 
-**Usage**: Only available during chat sessions. Clears the conversation history while keeping the session active.
+**Usage**: Only available during chat sessions. Clears the conversation history and all checkpoints while keeping the session active.
 
 ### `//review`
-Display current conversation context.
+Display current conversation context with checkpoint markers.
 
 **Syntax**: `//review`
 
 **Aliases**: `//context`
 
-Shows the current context manager state, including conversation history and metadata.
+**Example Output**:
+```
+=== Chat Context ===
+Total messages: 5
+Checkpoints: ruby_basics, oop_concepts
+
+1. [System]: You are a helpful assistant
+2. [User]: Tell me about Ruby programming
+3. [Assistant]: Ruby is a dynamic programming language...
+
+📍 [Checkpoint: ruby_basics]
+----------------------------------------
+4. [User]: Now explain object-oriented programming
+5. [Assistant]: Object-oriented programming (OOP) is...
+
+📍 [Checkpoint: oop_concepts]
+----------------------------------------
+=== End of Context ===
+```
+
+**Features**:
+- Shows complete conversation history with message numbers
+- Displays checkpoint markers (📍) at their exact positions
+- Lists all available checkpoints
+- Truncates long messages for readability (200 characters)
+- Shows total message count and checkpoint summary
 
 ## Model and Information Directives
 

data/docs/guides/chat.md

@@ -112,19 +112,71 @@ You: How do I handle user authentication?
 AI: For your Flask application, here are several authentication options...
 ```
 
+#### Context Checkpoints
+Create savepoints in your conversation to easily return to specific moments:
+
+```
+You: Let's explore different authentication approaches for Flask.
+AI: I can help you explore various authentication methods...
+
+You: //checkpoint auth_start
+
+You: Tell me about JWT authentication.
+AI: JWT (JSON Web Tokens) authentication is a stateless approach...
+
+You: //checkpoint jwt_discussion
+
+You: What about OAuth integration?
+AI: OAuth provides a robust framework for authentication...
+
+You: Actually, let's go back to the JWT discussion
+You: //restore jwt_discussion
+
+You: //context
+=== Chat Context ===
+Total messages: 6
+Checkpoints: auth_start, jwt_discussion
+
+1. [System]: You are a helpful assistant
+2. [User]: Let's explore different authentication approaches for Flask.
+3. [Assistant]: I can help you explore various authentication methods...
+
+📍 [Checkpoint: auth_start]
+----------------------------------------
+4. [User]: Tell me about JWT authentication.
+5. [Assistant]: JWT (JSON Web Tokens) authentication is a stateless approach...
+
+📍 [Checkpoint: jwt_discussion]
+----------------------------------------
+=== End of Context ===
+```
+
+**Checkpoint Commands**:
+- `//checkpoint` - Create auto-numbered checkpoint (1, 2, 3...)
+- `//checkpoint name` - Create named checkpoint
+- `//restore` - Restore to last checkpoint
+- `//restore name` - Restore to specific checkpoint
+- `//cp name` - Short alias for checkpoint
+
+**Use Cases for Checkpoints**:
+- **Exploring alternatives**: Save before trying different approaches
+- **Debugging conversations**: Return to working state after errors
+- **Session branching**: Explore multiple conversation paths
+- **Learning sessions**: Bookmark important explanations
+
 #### Context Inspection
 ```
-You: /context
-# Shows current conversation history and metadata
+You: //context
+# Shows current conversation history with checkpoint markers
+
+You: //review
+# Alternative command for context inspection
 ```
 
 #### Context Clearing
 ```
-You: /clear
-# Clears conversation history while keeping session active
-
-You: /new
-# Starts a completely fresh session
+You: //clear
+# Clears conversation history and all checkpoints while keeping session active
 ```
 
 ### Tool Integration in Chat

data/lib/aia/context_manager.rb

@@ -3,11 +3,13 @@
 module AIA
   # Manages the conversation context for chat sessions.
   class ContextManager
-    attr_reader :context
+    attr_reader :context, :checkpoints
 
     # Initializes the ContextManager with an optional system prompt.
     def initialize(system_prompt: nil)
       @context = []
+      @checkpoints = {}
+      @checkpoint_counter = 0
       add_system_prompt(system_prompt) if system_prompt && !system_prompt.strip.empty?
     end
 
@@ -43,6 +45,10 @@ module AIA
         @context = []
       end
 
+      # Clear all checkpoints when clearing context
+      @checkpoints.clear
+      @checkpoint_counter = 0
+
       # Attempt to clear the LLM client's context as well
       begin
         if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
@@ -61,6 +67,60 @@ module AIA
       end
     end
 
+    # Creates a checkpoint of the current context with an optional name.
+    #
+    # @param name [String, nil] The name of the checkpoint. If nil, uses an incrementing integer.
+    # @return [String] The name of the created checkpoint.
+    def create_checkpoint(name: nil)
+      if name.nil?
+        @checkpoint_counter += 1
+        name = @checkpoint_counter.to_s
+      end
+
+      # Store a deep copy of the current context and its position
+      @checkpoints[name] = {
+        context: @context.map(&:dup),
+        position: @context.size
+      }
+      @last_checkpoint_name = name
+      name
+    end
+
+    # Restores the context to a previously saved checkpoint.
+    #
+    # @param name [String, nil] The name of the checkpoint to restore. If nil, uses the last checkpoint.
+    # @return [Boolean] True if restore was successful, false otherwise.
+    def restore_checkpoint(name: nil)
+      name = @last_checkpoint_name if name.nil?
+
+      return false if name.nil? || !@checkpoints.key?(name)
+
+      # Restore the context from the checkpoint
+      checkpoint_data = @checkpoints[name]
+      @context = checkpoint_data[:context].map(&:dup)
+      true
+    end
+
+    # Returns the list of available checkpoint names.
+    #
+    # @return [Array<String>] The names of all checkpoints.
+    def checkpoint_names
+      @checkpoints.keys
+    end
+
+    # Returns checkpoint information mapped to context positions.
+    #
+    # @return [Hash<Integer, Array<String>>] Position to checkpoint names mapping.
+    def checkpoint_positions
+      positions = {}
+      @checkpoints.each do |name, data|
+        position = data[:position]
+        positions[position] ||= []
+        positions[position] << name
+      end
+      positions
+    end
+
     private
 
     # Adds or replaces the system prompt at the beginning of the context.

data/lib/aia/directives/configuration.rb

@@ -34,7 +34,7 @@ module AIA
             # Display details for all configured models
             puts
             models = Array(AIA.config.model)
-            
+
             if models.size == 1
               puts "Current Model:"
               puts "=============="
@@ -48,10 +48,10 @@ module AIA
               puts
               puts "Model Details:"
               puts "-" * 50
-              
+
               models.each_with_index do |model_name, index|
                 puts "#{index + 1}. #{model_name}#{index == 0 ? ' (primary)' : ''}"
-                
+
                 # Try to get model details if available
                 begin
                   # Access the model details from RubyLLM's model registry
@@ -98,16 +98,89 @@ module AIA
         end
 
       def self.review(args, context_manager = nil)
-          ap context_manager.get_context
+          return "Error: Context manager not available for //review directive." if context_manager.nil?
+
+          context = context_manager.get_context
+          checkpoint_positions = context_manager.checkpoint_positions
+
+          # Display context with checkpoint markers
+          puts "\n=== Chat Context ==="
+          puts "Total messages: #{context.size}"
+
+          if checkpoint_positions.any?
+            puts "Checkpoints: #{context_manager.checkpoint_names.join(', ')}"
+          end
+
+          puts "\n"
+
+          context.each_with_index do |message, index|
+            # Check if there's a checkpoint at this position
+            if checkpoint_positions[index]
+              checkpoint_names = checkpoint_positions[index].join(', ')
+              puts "📍 [Checkpoint: #{checkpoint_names}]"
+              puts "-" * 40
+            end
+
+            # Display the message
+            role_display = message[:role].capitalize
+            content_preview = message[:content].to_s
+
+            # Truncate long content for display
+            if content_preview.length > 200
+              content_preview = content_preview[0..197] + "..."
+            end
+
+            puts "#{index + 1}. [#{role_display}]: #{content_preview}"
+            puts ""
+          end
+
+          # Check if there's a checkpoint at the end (after all messages)
+          if checkpoint_positions[context.size]
+            checkpoint_names = checkpoint_positions[context.size].join(', ')
+            puts "📍 [Checkpoint: #{checkpoint_names}]"
+            puts "-" * 40
+          end
+
+          puts "=== End of Context ==="
           ''
         end
 
+      def self.checkpoint(args, context_manager = nil)
+          if context_manager.nil?
+            return "Error: Context manager not available for //checkpoint directive."
+          end
+
+          name = args.empty? ? nil : args.join(' ').strip
+          checkpoint_name = context_manager.create_checkpoint(name: name)
+          "Checkpoint '#{checkpoint_name}' created."
+        end
+
+      def self.restore(args, context_manager = nil)
+          if context_manager.nil?
+            return "Error: Context manager not available for //restore directive."
+          end
+
+          name = args.empty? ? nil : args.join(' ').strip
+
+          if context_manager.restore_checkpoint(name: name)
+            restored_name = name || context_manager.checkpoint_names.last
+            "Context restored to checkpoint '#{restored_name}'."
+          else
+            if name
+              "Error: Checkpoint '#{name}' not found. Available checkpoints: #{context_manager.checkpoint_names.join(', ')}"
+            else
+              "Error: No checkpoints available to restore."
+            end
+          end
+        end
+
       # Set up aliases - these work on the module's singleton class
       class << self
         alias_method :cfg, :config
         alias_method :temp, :temperature
         alias_method :topp, :top_p
         alias_method :context, :review
+        alias_method :ckp, :checkpoint
       end
     end
   end

data/lib/aia/directives/models.rb

@@ -85,30 +85,163 @@ module AIA
           puts "===================="
           puts
 
-          directives = self.methods(false).map(&:to_s).reject do |m|
-            ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases'].include?(m)
-          end.sort
-
-          build_aliases(directives)
+          # Manual descriptions for all directives
+          directive_descriptions = {
+            # Configuration directives
+            'config' => 'View or set configuration values',
+            'model' => 'View or change the AI model',
+            'temperature' => 'Set the temperature parameter for AI responses',
+            'top_p' => 'Set the top_p parameter for AI responses',
+            'clear' => 'Clear the conversation context',
+            'review' => 'Display the current conversation context with checkpoint markers',
+            'checkpoint' => 'Create a named checkpoint of the current context',
+            'restore' => 'Restore context to a previous checkpoint',
+
+            # Utility directives
+            'tools' => 'List available tools',
+            'next' => 'Set the next prompt in the sequence',
+            'pipeline' => 'Set or view the prompt workflow sequence',
+            'terse' => 'Add instruction for concise responses',
+            'robot' => 'Display ASCII robot art',
+
+            # Execution directives
+            'ruby' => 'Execute Ruby code',
+            'shell' => 'Execute shell commands',
+            'say' => 'Use text-to-speech to speak the text',
+
+            # Web and File directives
+            'webpage' => 'Fetch and include content from a webpage',
+            'include' => 'Include content from a file',
+            'include_file' => 'Include file content (internal use)',
+            'included_files' => 'List files that have been included',
+            'included_files=' => 'Set the list of included files',
+
+            # Model directives
+            'available_models' => 'List all available AI models',
+            'compare' => 'Compare responses from multiple models',
+            'help' => 'Show this help message',
+
+            # Aliases (these get their descriptions from main directive)
+            'cfg' => nil,  # alias for config
+            'temp' => nil, # alias for temperature
+            'topp' => nil, # alias for top_p
+            'context' => nil, # alias for review
+            'cp' => nil, # alias for checkpoint
+            'workflow' => nil, # alias for pipeline
+            'rb' => nil, # alias for ruby
+            'sh' => nil, # alias for shell
+            'web' => nil, # alias for webpage
+            'website' => nil, # alias for webpage
+            'import' => nil, # alias for include
+            'models' => nil, # alias for available_models
+            'all_models' => nil, # alias for available_models
+            'am' => nil, # alias for available_models
+            'llms' => nil, # alias for available_models
+            'available' => nil, # alias for available_models
+            'cmp' => nil, # alias for compare
+          }
+
+          # Get all registered directive modules from the Registry
+          all_modules = [
+            AIA::Directives::WebAndFile,
+            AIA::Directives::Utility,
+            AIA::Directives::Configuration,
+            AIA::Directives::Execution,
+            AIA::Directives::Models
+          ]
+
+          all_directives = {}
+          excluded_methods = ['run', 'initialize', 'private?', 'descriptions', 'aliases', 'build_aliases',
+                             'desc', 'method_added', 'register_directive_module', 'process',
+                             'directive?', 'prefix_size']
+
+          # Collect directives from all modules
+          all_modules.each do |mod|
+            methods = mod.methods(false).map(&:to_s).reject { |m| excluded_methods.include?(m) }
+
+            methods.each do |method|
+              # Skip if this is an alias (has nil description)
+              next if directive_descriptions.key?(method) && directive_descriptions[method].nil?
+
+              description = directive_descriptions[method] || method.gsub('_', ' ').capitalize
+
+              all_directives[method] = {
+                module: mod.name.split('::').last,
+                description: description,
+                aliases: []
+              }
+            end
+          end
 
-          directives.each do |directive|
-            next unless descriptions[directive]
+          # Manually map known aliases
+          alias_mappings = {
+            'config' => ['cfg'],
+            'temperature' => ['temp'],
+            'top_p' => ['topp'],
+            'review' => ['context'],
+            'checkpoint' => ['cp'],
+            'pipeline' => ['workflow'],
+            'ruby' => ['rb'],
+            'shell' => ['sh'],
+            'webpage' => ['web', 'website'],
+            'include' => ['import'],
+            'available_models' => ['models', 'all_models', 'am', 'llms', 'available'],
+            'compare' => ['cmp']
+          }
+
+          # Apply alias mappings
+          alias_mappings.each do |directive, aliases|
+            if all_directives[directive]
+              all_directives[directive][:aliases] = aliases
+            end
+          end
 
-            others = aliases[directive]
+          # Sort and display directives by category
+          categories = {
+            'Configuration' => ['config', 'model', 'temperature', 'top_p', 'clear', 'review', 'checkpoint', 'restore'],
+            'Utility' => ['tools', 'next', 'pipeline', 'terse', 'robot', 'help'],
+            'Execution' => ['ruby', 'shell', 'say'],
+            'Web & Files' => ['webpage', 'include'],
+            'Models' => ['available_models', 'compare']
+          }
+
+          categories.each do |category, directives|
+            puts "#{category}:"
+            puts "-" * category.length
+
+            directives.each do |directive|
+              info = all_directives[directive]
+              next unless info
+
+              if info[:aliases] && !info[:aliases].empty?
+                with_prefix = info[:aliases].map { |m| PromptManager::Prompt::DIRECTIVE_SIGNAL + m }
+                alias_text = " (aliases: #{with_prefix.join(', ')})"
+              else
+                alias_text = ""
+              end
 
-            if others.empty?
-              others_line = ""
-            else
-              with_prefix = others.map { |m| PromptManager::Prompt::DIRECTIVE_SIGNAL + m }
-              others_line = "\tAliases:#{with_prefix.join('  ')}\n"
+              puts "  //#{directive}#{alias_text}"
+              puts "      #{info[:description]}"
+              puts
             end
+          end
 
-            puts <<~TEXT
-              //#{directive} #{descriptions[directive]}
-              #{others_line}
-            TEXT
+          # Show any uncategorized directives
+          categorized = categories.values.flatten
+          uncategorized = all_directives.keys - categorized - ['include_file', 'included_files', 'included_files=']
+
+          if uncategorized.any?
+            puts "Other:"
+            puts "------"
+            uncategorized.sort.each do |directive|
+              info = all_directives[directive]
+              puts "  //#{directive}"
+              puts "      #{info[:description]}"
+              puts
+            end
           end
 
+          puts "\nTotal: #{all_directives.size} directives available"
           ""
         end
 

data/lib/aia/session.rb

@@ -407,10 +407,12 @@ module AIA
 
     def process_chat_directive(follow_up_prompt)
       directive_output = @directive_processor.process(follow_up_prompt, @context_manager)
-      
+
       return handle_clear_directive if follow_up_prompt.strip.start_with?("//clear")
+      return handle_checkpoint_directive(directive_output) if follow_up_prompt.strip.start_with?("//checkpoint")
+      return handle_restore_directive(directive_output) if follow_up_prompt.strip.start_with?("//restore")
       return handle_empty_directive_output if directive_output.nil? || directive_output.strip.empty?
-      
+
       handle_successful_directive(follow_up_prompt, directive_output)
     end
 
@@ -438,6 +440,31 @@ module AIA
       nil
     end
 
+    def handle_checkpoint_directive(directive_output)
+      @ui_presenter.display_info(directive_output)
+      nil
+    end
+
+    def handle_restore_directive(directive_output)
+      # If the restore was successful, we also need to refresh the client's context
+      if directive_output.start_with?("Context restored")
+        # Try to clear and rebuild the client's context
+        if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
+          AIA.config.client.clear_context
+        end
+
+        # Optionally reinitialize the client for a clean state
+        begin
+          AIA.config.client = AIA::RubyLLMAdapter.new
+        rescue => e
+          STDERR.puts "Error reinitializing client after restore: #{e.message}"
+        end
+      end
+
+      @ui_presenter.display_info(directive_output)
+      nil
+    end
+
     def handle_empty_directive_output
       nil
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.13
+  version: 0.9.14
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -433,7 +433,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Multi-model AI CLI with dynamic prompts, consensus responses, shell & Ruby
   integration, and seamless chat workflows.