janito 0.12.0__tar.gz → 0.13.0__tar.gz

{janito-0.12.0 → janito-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 0.12.0
+Version: 0.13.0
 Summary: Janito CLI tool
 Project-URL: Homepage, https://github.com/joaompinto/janito
 Author-email: João Pinto <lamego.pinto@gmail.com>
@@ -35,6 +35,8 @@ Janito is a powerful AI-assisted command-line interface (CLI) tool built with Py
 - 🌐 Web page fetching with content extraction capabilities
 - 🔄 Parameter profiles for optimizing Claude's behavior for different tasks
 - 📋 Line delta tracking to monitor net changes in files
+- 💬 Conversation history with ability to resume previous conversations
+- 🔇 Trust mode for concise output without tool details
 
 ## 🛠️ System Requirements
 
@@ -108,14 +110,24 @@ janito --show-tokens "Explain what is in the project"
 # Use a specific parameter profile for creative tasks
 janito --profile creative "Write a fun description for our project"
 
-# Continue previous conversation
-janito --continue "Plese add one more line"
+# Use trust mode for concise output without tool details
+janito --trust "Optimize the HTML code"
+# Or use the short alias
+janito -t "Optimize the HTML code"
+
+# Continue the most recent conversation
+janito --continue "Please add one more line"
+
+# Continue a specific conversation using its message ID
+# (Janito displays the message ID after each conversation)
+janito --continue abc123def "Let's refine that code"
 
 # Show current configuration and available profiles
 janito --show-config
 
 # You can press Ctrl+C at any time to interrupt a query
 # Janito will still display token and tool usage information
+# Even interrupted conversations can be continued with --continue
 ```
 
 ## 🔧 Available Tools
@@ -134,7 +146,7 @@ Janito comes with several built-in tools:
 Janito includes a comprehensive token usage tracking system that helps you monitor API costs:
 
 - **Basic tracking**: By default, Janito displays a summary of token usage and cost after each query
-- **Detailed reporting**: Use the `--show-tokens` or `-t` flag to see detailed breakdowns including:
+- **Detailed reporting**: Use the `--show-tokens` flag to see detailed breakdowns including:
   - Input and output token counts
   - Per-tool token usage statistics
   - Precise cost calculations
@@ -147,6 +159,11 @@ janito --show-tokens "Write a Python function to sort a list"
 
 # Basic usage (shows simplified token usage summary)
 janito "Explain Docker containers"
+
+# Use trust mode for concise output without tool details
+janito --trust "Create a simple Python script"
+# Or use the short alias
+janito -t "Create a simple Python script"
 ```
 
 The usage tracker automatically calculates cache savings, showing you how much you're saving by reusing previous responses.
@@ -169,6 +186,64 @@ janito --profile creative "Write a poem about coding"
 janito --show-config
 ```
 
+## 🔇 Trust Mode
+
+Janito offers a trust mode that suppresses tool outputs for a more concise execution experience:
+
+### How It Works
+
+- When enabled with `--trust` or `-t`, Janito suppresses informational and success messages from tools
+- Only essential output and error messages are displayed
+- The final result from Claude is still shown in full
+- Trust mode is a per-session setting and not saved to your configuration
+
+### Using Trust Mode
+
+```bash
+# Enable trust mode with the full flag
+janito --trust "Create a Python script that reads a CSV file"
+
+# Or use the short alias
+janito -t "Create a Python script that reads a CSV file"
+```
+
+This feature is particularly useful for:
+- Experienced users who don't need to see every step of the process
+- Batch processing or scripting where concise output is preferred
+- Focusing on results rather than the process
+- Creating cleaner output for documentation or sharing
+
+## 💬 Conversation History
+
+Janito automatically saves your conversation history, allowing you to continue previous discussions:
+
+### How It Works
+
+- Each conversation is saved with a unique message ID in `.janito/last_messages/`
+- The most recent conversation is also saved as `.janito/last_message.json` for backward compatibility
+- After each conversation, Janito displays the command to continue that specific conversation
+
+### Using the Continue Feature
+
+```bash
+# Continue the most recent conversation
+janito --continue "Add more details to your previous response"
+
+# Continue a specific conversation using its ID
+janito --continue abc123def "Let's modify that code you suggested"
+```
+
+The `--continue` flag (or `-c` for short) allows you to:
+- Resume the most recent conversation when used without an ID
+- Resume a specific conversation when provided with a message ID
+- Maintain context across multiple interactions for complex tasks
+
+This feature is particularly useful for:
+- Multi-step development tasks
+- Iterative code improvements
+- Continuing discussions after system interruptions
+- Maintaining context when working on complex problems
+
 ## ⚙️ Dependencies
 
 Janito automatically installs the following dependencies:
@@ -177,6 +252,28 @@ Janito automatically installs the following dependencies:
 - claudine - For Claude AI integration
 - Additional packages for file handling and web content extraction
 
+## 🛠️ Command-Line Options
+
+Janito offers a variety of command-line options to customize its behavior:
+
+```
+--verbose, -v                 Enable verbose mode with detailed output
+--show-tokens                 Show detailed token usage and pricing information
+--workspace, -w TEXT          Set the workspace directory
+--set-config TEXT             Configuration string in format 'key=value', e.g., 'temperature=0.7'
+--show-config                 Show current configuration
+--reset-config                Reset configuration by removing the config file
+--set-api-key TEXT            Set the Anthropic API key globally in the user's home directory
+--ask                         Enable ask mode which disables tools that perform changes
+--trust, -t                   Enable trust mode which suppresses tool outputs for concise execution
+--temperature FLOAT           Set the temperature for model generation (0.0 to 1.0)
+--profile TEXT                Use a predefined parameter profile (precise, balanced, conversational, creative, technical)
+--role TEXT                   Set the assistant's role (default: 'software engineer')
+--version                     Show the version and exit
+--continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--help                        Show the help message and exit
+```
+
 ## 🔑 API Key Configuration
 
 You can configure your Anthropic API key in several ways:

{janito-0.12.0 → janito-0.13.0}/README.md

@@ -15,6 +15,8 @@ Janito is a powerful AI-assisted command-line interface (CLI) tool built with Py
 - 🌐 Web page fetching with content extraction capabilities
 - 🔄 Parameter profiles for optimizing Claude's behavior for different tasks
 - 📋 Line delta tracking to monitor net changes in files
+- 💬 Conversation history with ability to resume previous conversations
+- 🔇 Trust mode for concise output without tool details
 
 ## 🛠️ System Requirements
 
@@ -88,14 +90,24 @@ janito --show-tokens "Explain what is in the project"
 # Use a specific parameter profile for creative tasks
 janito --profile creative "Write a fun description for our project"
 
-# Continue previous conversation
-janito --continue "Plese add one more line"
+# Use trust mode for concise output without tool details
+janito --trust "Optimize the HTML code"
+# Or use the short alias
+janito -t "Optimize the HTML code"
+
+# Continue the most recent conversation
+janito --continue "Please add one more line"
+
+# Continue a specific conversation using its message ID
+# (Janito displays the message ID after each conversation)
+janito --continue abc123def "Let's refine that code"
 
 # Show current configuration and available profiles
 janito --show-config
 
 # You can press Ctrl+C at any time to interrupt a query
 # Janito will still display token and tool usage information
+# Even interrupted conversations can be continued with --continue
 ```
 
 ## 🔧 Available Tools
@@ -114,7 +126,7 @@ Janito comes with several built-in tools:
 Janito includes a comprehensive token usage tracking system that helps you monitor API costs:
 
 - **Basic tracking**: By default, Janito displays a summary of token usage and cost after each query
-- **Detailed reporting**: Use the `--show-tokens` or `-t` flag to see detailed breakdowns including:
+- **Detailed reporting**: Use the `--show-tokens` flag to see detailed breakdowns including:
   - Input and output token counts
   - Per-tool token usage statistics
   - Precise cost calculations
@@ -127,6 +139,11 @@ janito --show-tokens "Write a Python function to sort a list"
 
 # Basic usage (shows simplified token usage summary)
 janito "Explain Docker containers"
+
+# Use trust mode for concise output without tool details
+janito --trust "Create a simple Python script"
+# Or use the short alias
+janito -t "Create a simple Python script"
 ```
 
 The usage tracker automatically calculates cache savings, showing you how much you're saving by reusing previous responses.
@@ -149,6 +166,64 @@ janito --profile creative "Write a poem about coding"
 janito --show-config
 ```
 
+## 🔇 Trust Mode
+
+Janito offers a trust mode that suppresses tool outputs for a more concise execution experience:
+
+### How It Works
+
+- When enabled with `--trust` or `-t`, Janito suppresses informational and success messages from tools
+- Only essential output and error messages are displayed
+- The final result from Claude is still shown in full
+- Trust mode is a per-session setting and not saved to your configuration
+
+### Using Trust Mode
+
+```bash
+# Enable trust mode with the full flag
+janito --trust "Create a Python script that reads a CSV file"
+
+# Or use the short alias
+janito -t "Create a Python script that reads a CSV file"
+```
+
+This feature is particularly useful for:
+- Experienced users who don't need to see every step of the process
+- Batch processing or scripting where concise output is preferred
+- Focusing on results rather than the process
+- Creating cleaner output for documentation or sharing
+
+## 💬 Conversation History
+
+Janito automatically saves your conversation history, allowing you to continue previous discussions:
+
+### How It Works
+
+- Each conversation is saved with a unique message ID in `.janito/last_messages/`
+- The most recent conversation is also saved as `.janito/last_message.json` for backward compatibility
+- After each conversation, Janito displays the command to continue that specific conversation
+
+### Using the Continue Feature
+
+```bash
+# Continue the most recent conversation
+janito --continue "Add more details to your previous response"
+
+# Continue a specific conversation using its ID
+janito --continue abc123def "Let's modify that code you suggested"
+```
+
+The `--continue` flag (or `-c` for short) allows you to:
+- Resume the most recent conversation when used without an ID
+- Resume a specific conversation when provided with a message ID
+- Maintain context across multiple interactions for complex tasks
+
+This feature is particularly useful for:
+- Multi-step development tasks
+- Iterative code improvements
+- Continuing discussions after system interruptions
+- Maintaining context when working on complex problems
+
 ## ⚙️ Dependencies
 
 Janito automatically installs the following dependencies:
@@ -157,6 +232,28 @@ Janito automatically installs the following dependencies:
 - claudine - For Claude AI integration
 - Additional packages for file handling and web content extraction
 
+## 🛠️ Command-Line Options
+
+Janito offers a variety of command-line options to customize its behavior:
+
+```
+--verbose, -v                 Enable verbose mode with detailed output
+--show-tokens                 Show detailed token usage and pricing information
+--workspace, -w TEXT          Set the workspace directory
+--set-config TEXT             Configuration string in format 'key=value', e.g., 'temperature=0.7'
+--show-config                 Show current configuration
+--reset-config                Reset configuration by removing the config file
+--set-api-key TEXT            Set the Anthropic API key globally in the user's home directory
+--ask                         Enable ask mode which disables tools that perform changes
+--trust, -t                   Enable trust mode which suppresses tool outputs for concise execution
+--temperature FLOAT           Set the temperature for model generation (0.0 to 1.0)
+--profile TEXT                Use a predefined parameter profile (precise, balanced, conversational, creative, technical)
+--role TEXT                   Set the assistant's role (default: 'software engineer')
+--version                     Show the version and exit
+--continue, -c TEXT           Continue a previous conversation, optionally with a specific message ID
+--help                        Show the help message and exit
+```
+
 ## 🔑 API Key Configuration
 
 You can configure your Anthropic API key in several ways:

janito-0.13.0/janito/__init__.py

@@ -0,0 +1,5 @@
+"""
+Janito package.
+"""
+
+__version__ = "0.13.0"

{janito-0.12.0 → janito-0.13.0}/janito/cli/agent.py

@@ -7,6 +7,8 @@ import json
 import anthropic
 import claudine
 import typer
+import datetime
+from typing import Optional
 from rich.console import Console
 from pathlib import Path
 from jinja2 import Template
@@ -19,6 +21,7 @@ from janito.tools import str_replace_editor
 from janito.tools.bash.bash import bash_tool
 from janito.cli.output import display_generation_params
 
+
 console = Console()
 
 def get_api_key() -> str:
@@ -154,12 +157,25 @@ def initialize_agent(temperature: float, verbose: bool) -> claudine.Agent:
     
     return agent
 
+def generate_message_id():
+    """
+    Generate a message ID based on timestamp with seconds granularity
+    
+    Returns:
+        str: A timestamp-based message ID
+    """
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    return timestamp
+
 def save_messages(agent):
     """
-    Save agent messages to .janito/last_message.json
+    Save agent messages to .janito/last_messages/{message_id}.json
     
     Args:
         agent: The claudine agent instance
+        
+    Returns:
+        str: The message ID used for saving
     """
     try:
         # Get the workspace directory
@@ -169,49 +185,115 @@ def save_messages(agent):
         janito_dir = workspace_dir / ".janito"
         janito_dir.mkdir(exist_ok=True)
         
+        # Create last_messages directory if it doesn't exist
+        messages_dir = janito_dir / "last_messages"
+        messages_dir.mkdir(exist_ok=True)
+        
+        # Generate a unique message ID
+        message_id = generate_message_id()
+        
         # Get messages from the agent
         messages = agent.get_messages()
         
+        # Create a message object with metadata
+        message_object = {
+            "id": message_id,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "messages": messages
+        }
+        
         # Save messages to file
-        with open(janito_dir / "last_message.json", "w", encoding="utf-8") as f:
-            json.dump(messages, f, ensure_ascii=False, indent=2)
+        message_file = messages_dir / f"{message_id}.json"
+        with open(message_file, "w", encoding="utf-8") as f:
+            json.dump(message_object, f, ensure_ascii=False, indent=2)
+        
+        # No longer saving to last_message.json for backward compatibility
             
         if get_config().verbose:
-            console.print(f"[bold green]✅ Conversation saved to {janito_dir / 'last_message.json'}[/bold green]")
+            console.print(f"[bold green]✅ Conversation saved to {message_file}[/bold green]")
+            
+        return message_id
     except Exception as e:
         console.print(f"[bold red]❌ Error saving conversation:[/bold red] {str(e)}")
+        return None
 
-def load_messages():
+def load_messages(message_id=None):
     """
-    Load messages from .janito/last_message.json
+    Load messages from .janito/last_messages/{message_id}.json or the latest message file
     
+    Args:
+        message_id: Optional message ID to load specific conversation
+        
     Returns:
         List of message dictionaries or None if file doesn't exist
     """
     try:
         # Get the workspace directory
         workspace_dir = Path(get_config().workspace_dir)
+        janito_dir = workspace_dir / ".janito"
+        messages_dir = janito_dir / "last_messages"
+        
+        # If message_id is provided, try to load that specific conversation
+        if message_id:
+            # Check if the message ID is a file name or just the ID
+            if message_id.endswith('.json'):
+                message_file = messages_dir / message_id
+            else:
+                message_file = messages_dir / f"{message_id}.json"
+                
+            if not message_file.exists():
+                console.print(f"[bold yellow]⚠️ No conversation found with ID {message_id}[/bold yellow]")
+                return None
+                
+            # Load messages from file
+            with open(message_file, "r", encoding="utf-8") as f:
+                message_object = json.load(f)
+                
+            # Extract messages from the message object
+            if isinstance(message_object, dict) and "messages" in message_object:
+                messages = message_object["messages"]
+            else:
+                # Handle legacy format
+                messages = message_object
+                
+            if get_config().verbose:
+                console.print(f"[bold green]✅ Loaded conversation from {message_file}[/bold green]")
+                console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
+                
+            return messages
         
-        # Check if file exists
-        messages_file = workspace_dir / ".janito" / "last_message.json"
-        if not messages_file.exists():
+        # If no message_id is provided, try to load the latest message from last_messages directory
+        if not messages_dir.exists() or not any(messages_dir.iterdir()):
             console.print("[bold yellow]⚠️ No previous conversation found[/bold yellow]")
             return None
         
-        # Load messages from file
-        with open(messages_file, "r", encoding="utf-8") as f:
-            messages = json.load(f)
+        # Find the latest message file (based on filename which is a timestamp)
+        latest_file = max(
+            [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json'],
+            key=lambda x: x.stem
+        )
+        
+        # Load messages from the latest file
+        with open(latest_file, "r", encoding="utf-8") as f:
+            message_object = json.load(f)
+            
+        # Extract messages from the message object
+        if isinstance(message_object, dict) and "messages" in message_object:
+            messages = message_object["messages"]
+        else:
+            # Handle legacy format
+            messages = message_object
             
         if get_config().verbose:
-            console.print(f"[bold green]✅ Loaded previous conversation from {messages_file}[/bold green]")
+            console.print(f"[bold green]✅ Loaded latest conversation from {latest_file}[/bold green]")
             console.print(f"[dim]📝 Conversation has {len(messages)} messages[/dim]")
             
         return messages
     except Exception as e:
-        console.print(f"[bold red]❌ Error loading previous conversation:[/bold red] {str(e)}")
+        console.print(f"[bold red]❌ Error loading conversation:[/bold red] {str(e)}")
         return None
 
-def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: bool = False) -> None:
+def handle_query(query: str, temperature: float, verbose: bool, show_tokens: bool, continue_conversation: Optional[str] = None) -> None:
     """
     Handle a query by initializing the agent and sending the query.
     
@@ -220,24 +302,29 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         temperature: Temperature value for model generation
         verbose: Whether to enable verbose mode
         show_tokens: Whether to show detailed token usage
-        continue_conversation: Whether to continue the previous conversation
+        continue_conversation: Optional message ID to continue a specific conversation
     """
     # Initialize the agent
     agent = initialize_agent(temperature, verbose)
     
     # Load previous messages if continuing conversation
-    if continue_conversation:
-        messages = load_messages()
+    if continue_conversation is not None:
+        # If continue_conversation is an empty string (from flag with no value), use default behavior
+        message_id = None if continue_conversation == "" else continue_conversation
+        messages = load_messages(message_id)
         if messages:
             agent.set_messages(messages)
-            console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
+            if message_id:
+                console.print(f"[bold blue]🔄 Continuing conversation with ID: {message_id}[/bold blue]")
+            else:
+                console.print("[bold blue]🔄 Continuing previous conversation[/bold blue]")
     
     # Send the query to the agent
     try:
         agent.query(query)
         
-        # Save messages after successful query
-        save_messages(agent)
+        # Save messages after successful query and get the message ID
+        message_id = save_messages(agent)
         
         # Print token usage report
         if show_tokens:
@@ -249,13 +336,26 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
         # Print tool usage statistics
         from janito.tools import print_usage_stats
         print_usage_stats()
+        
+        # Show message about continuing this conversation
+        if message_id:
+            script_name = "janito"
+            try:
+                # Check if we're running from the entry point script or as a module
+                if sys.argv[0].endswith(('janito', 'janito.exe')):
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] {script_name} --continue {message_id} <request>")
+                else:
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] python -m janito --continue {message_id} <request>")
+            except:
+                # Fallback message
+                console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] --continue {message_id} <request>")
             
     except KeyboardInterrupt:
         # Handle Ctrl+C by printing token and tool usage information
         console.print("\n[bold yellow]⚠️ Query interrupted by user (Ctrl+C)[/bold yellow]")
         
         # Save messages even if interrupted
-        save_messages(agent)
+        message_id = save_messages(agent)
         
         # Print token usage report (even if interrupted)
         try:
@@ -268,6 +368,19 @@ def handle_query(query: str, temperature: float, verbose: bool, show_tokens: boo
             # Print tool usage statistics
             from janito.tools import print_usage_stats
             print_usage_stats()
+            
+            # Show message about continuing this conversation
+            if message_id:
+                script_name = "janito"
+                try:
+                    # Check if we're running from the entry point script or as a module
+                    if sys.argv[0].endswith(('janito', 'janito.exe')):
+                        console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] {script_name} --continue {message_id} <request>")
+                    else:
+                        console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] python -m janito --continue {message_id} <request>")
+                except:
+                    # Fallback message
+                    console.print(f"[bold green]💬 This conversation can be continued with:[/bold green] --continue {message_id} <request>")
         except Exception as e:
             console.print(f"[bold red]❌ Error generating usage report:[/bold red] {str(e)}")
             if verbose:

{janito-0.12.0 → janito-0.13.0}/janito/cli/app.py

@@ -19,18 +19,19 @@ console = Console()
 def main(ctx: typer.Context, 
          query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
          verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode with detailed output"),
-         show_tokens: bool = typer.Option(False, "--show-tokens", "-t", help="Show detailed token usage and pricing information"),
+         show_tokens: bool = typer.Option(False, "--show-tokens", "--tokens", help="Show detailed token usage and pricing information"),
          workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory"),
          config_str: Optional[str] = typer.Option(None, "--set-config", help="Configuration string in format 'key=value', e.g., 'temperature=0.7' or 'profile=technical'"),
          show_config: bool = typer.Option(False, "--show-config", help="Show current configuration"),
          reset_config: bool = typer.Option(False, "--reset-config", help="Reset configuration by removing the config file"),
          set_api_key: Optional[str] = typer.Option(None, "--set-api-key", help="Set the Anthropic API key globally in the user's home directory"),
          ask: bool = typer.Option(False, "--ask", help="Enable ask mode which disables tools that perform changes"),
+         trust: bool = typer.Option(False, "--trust", "-t", help="Enable trust mode which suppresses tool outputs for a more concise execution (per-session setting)"),
          temperature: float = typer.Option(0.0, "--temperature", help="Set the temperature for model generation (0.0 to 1.0)"),
          profile: Optional[str] = typer.Option(None, "--profile", help="Use a predefined parameter profile (precise, balanced, conversational, creative, technical)"),
          role: Optional[str] = typer.Option(None, "--role", help="Set the assistant's role (default: 'software engineer')"),
          version: bool = typer.Option(False, "--version", help="Show the version and exit"),
-         continue_conversation: bool = typer.Option(False, "--continue", "-c", help="Continue the previous conversation")):
+         continue_conversation: Optional[str] = typer.Option(None, "--continue", "-c", help="Continue a previous conversation, optionally with a specific message ID")):
     """
     Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
     """    
@@ -40,9 +41,16 @@ def main(ctx: typer.Context,
     # Set ask mode in config
     get_config().ask_mode = ask
     
+    # Set trust mode in config
+    get_config().trust_mode = trust
+    
     # Show a message if ask mode is enabled
     if ask:
         console.print("[bold yellow]⚠️ Ask Mode enabled:[/bold yellow] 🔒 Tools that perform changes are disabled")
+        
+    # Show a message if trust mode is enabled
+    if trust:
+        console.print("[bold blue]⚡ Trust Mode enabled:[/bold blue] Tool outputs are suppressed for concise execution (per-session setting)")
     
     # Show version and exit if requested
     if version:

{janito-0.12.0 → janito-0.13.0}/janito/cli/commands.py

@@ -285,7 +285,7 @@ def handle_config_commands(
     set_api_key: Optional[str],
     config_str: Optional[str],
     query: Optional[str],
-    continue_conversation: bool = False
+    continue_conversation: Optional[str] = None
 ) -> bool:
     """
     Handle all configuration-related commands.
@@ -300,7 +300,7 @@ def handle_config_commands(
         set_api_key: API key
         config_str: Configuration string in format 'key=value'
         query: Query string
-        continue_conversation: Whether to continue the previous conversation
+        continue_conversation: Optional message ID to continue a specific conversation
         
     Returns:
         bool: True if the program should exit after these operations