janito 0.7.0__tar.gz → 0.9.0__tar.gz

{janito-0.7.0 → janito-0.9.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 João Pinto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) [year] [copyright holder]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

janito-0.9.0/MANIFEST.in

@@ -0,0 +1 @@
+include janito/data/*.txt

janito-0.9.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.2
+Name: janito
+Version: 0.9.0
+Summary: Janito CLI tool
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: claudine>=0.1.0

janito-0.9.0/README.md

@@ -0,0 +1,75 @@
+# 🤖 Janito
+
+Janito is a powerful AI-assisted command-line interface (CLI) tool built with Python, leveraging Anthropic's Claude for intelligent code and file management.
+
+## ✨ Features
+
+- 🧠 Intelligent AI assistant powered by Claude
+- 📁 File management capabilities 
+- 🔍 Smart code search and editing
+- 💻 Interactive terminal interface with rich formatting
+- 📊 Token usage tracking and cost reporting
+
+## 🛠️ Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/joaompinto/janito.git
+cd janito
+
+# Install the package
+pip install -e .
+```
+
+## 🚀 Usage
+
+After installation, you can use the `janito` command in your terminal:
+
+```bash
+# Get help
+janito --help
+
+
+# Ask the AI assistant a question
+janito "Suggest improvements to this project"
+
+janito "Add a --version to the cli to report he version"
+
+```
+
+## 🔧 Available Tools
+
+Janito comes with several built-in tools:
+- 📄 `str_replace_editor` - View, create, and edit files
+- 🔎 `find_files` - Find files matching patterns
+- 🗑️ `delete_file` - Delete files
+- 🔍 `search_text` - Search for text patterns in files
+
+## ⚙️ Requirements
+
+- Python 3.8 or higher
+- Dependencies:
+  - typer (>=0.9.0)
+  - rich (>=13.0.0)
+  - claudine (for Claude AI integration)
+
+## 🔑 API Key
+
+Janito requires an Anthropic API key to function. You can:
+1. Set it as an environment variable: `export ANTHROPIC_API_KEY=your_api_key`
+2. Or enter it when prompted
+
+## 💻 Development
+
+```bash
+# Create a virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+## 📜 License
+
+[Add your license information here]

janito-0.9.0/janito/__init__.py

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

janito-0.9.0/janito/__main__.py

@@ -0,0 +1,151 @@
+"""
+Main entry point for the janito CLI.
+"""
+
+import typer
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from rich.console import Console
+from rich import print as rprint
+from rich.markdown import Markdown
+import claudine
+from claudine.exceptions import MaxTokensExceededException, MaxRoundsExceededException
+import locale
+
+# Fix console encoding for Windows
+if sys.platform == 'win32':
+    # Try to set UTF-8 mode for Windows 10 version 1903 or newer
+    os.system('chcp 65001 > NUL')
+    # Ensure stdout and stderr are using UTF-8
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+    # Set locale to UTF-8
+    locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+
+from janito.tools.str_replace_editor.editor import str_replace_editor
+from janito.tools.find_files import find_files
+from janito.tools.delete_file import delete_file
+from janito.tools.search_text import search_text
+from janito.config import get_config
+from janito.callbacks import pre_tool_callback, post_tool_callback
+from janito.token_report import generate_token_report
+
+app = typer.Typer(help="Janito CLI tool")
+
+@app.command()
+def hello(name: str = typer.Argument("World", help="Name to greet")):
+    """
+    Say hello to someone.
+    """
+    rprint(f"[bold green]Hello {name}[/bold green]")
+    
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, 
+         query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
+         debug: bool = typer.Option(False, "--debug", "-d", help="Enable debug mode"),
+         verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed token usage and pricing information"),
+         workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory")):
+    """
+    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
+    """    
+    console = Console()
+    
+    # Set debug mode in config
+    get_config().debug_mode = debug
+    
+    if workspace:
+        try:
+            print(f"Setting workspace directory to: {workspace}")
+            get_config().workspace_dir = workspace
+            print(f"Workspace directory set to: {get_config().workspace_dir}")
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            sys.exit(1)
+            
+    if ctx.invoked_subcommand is None:
+        # If no query provided in command line, read from stdin
+        if not query:
+            console.print("[bold blue]No query provided in command line. Reading from stdin...[/bold blue]")
+            query = sys.stdin.read().strip()
+            
+        # Only proceed if we have a query (either from command line or stdin)
+        if query:
+            # Get API key from environment variable or ask the user
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+            if not api_key:
+                console.print("[bold yellow]Warning:[/bold yellow] ANTHROPIC_API_KEY environment variable not set.")
+                console.print("Please set it or provide your API key now:")
+                api_key = typer.prompt("Anthropic API Key", hide_input=True)
+        
+            # Load instructions from file
+            import importlib.resources as pkg_resources
+            try:
+                # For Python 3.9+
+                try:
+                    from importlib.resources import files
+                    instructions = files('janito.data').joinpath('instructions.txt').read_text()
+                # Fallback for older Python versions
+                except (ImportError, AttributeError):
+                    instructions = pkg_resources.read_text('janito.data', 'instructions.txt')
+                instructions = instructions.strip()
+            except Exception as e:
+                console.print(f"[bold yellow]Warning:[/bold yellow] Could not load instructions file: {str(e)}")
+                console.print("[dim]Using default instructions instead.[/dim]")
+                instructions = "You are a helpful AI assistant. Answer the user's questions to the best of your ability."
+                   
+            # Initialize the agent with the tools
+            agent = claudine.Agent(
+                api_key=api_key,
+                tools=[
+                    delete_file,
+                    find_files,
+                    search_text
+                ],
+                text_editor_tool=str_replace_editor,
+                tool_callbacks=(pre_tool_callback, post_tool_callback),
+                max_tokens=4096,
+                temperature=0.7,
+                instructions=instructions,
+                debug_mode=debug  # Enable debug mode
+            )
+        
+            # Process the query
+            console.print(f"[bold blue]Query:[/bold blue] {query}")
+            console.print("[bold blue]Generating response...[/bold blue]")
+            
+            try:
+                response = agent.process_prompt(query)
+                
+                console.print("\n[bold green]Janito:[/bold green]")
+                # Use rich's enhanced Markdown rendering for the response
+                console.print(Markdown(response, code_theme="monokai"))
+                
+            except MaxTokensExceededException as e:
+                # Display the partial response if available
+                if e.response_text:
+                    console.print("\n[bold green]Partial Janito:[/bold green]")
+                    console.print(Markdown(e.response_text, code_theme="monokai"))
+                
+                console.print("\n[bold red]Error:[/bold red] Response was truncated because it reached the maximum token limit.")
+                console.print("[dim]Consider increasing the max_tokens parameter or simplifying your query.[/dim]")
+                
+            except MaxRoundsExceededException as e:
+                # Display the final response if available
+                if e.response_text:
+                    console.print("\n[bold green]Janito:[/bold green]")
+                    console.print(Markdown(e.response_text, code_theme="monokai"))
+                
+                console.print(f"\n[bold red]Error:[/bold red] Maximum number of tool execution rounds ({e.rounds}) reached. Some tasks may be incomplete.")
+                console.print("[dim]Consider increasing the max_rounds parameter or breaking down your task into smaller steps.[/dim]")
+            
+            # Show token usage report
+            generate_token_report(agent, verbose)
+        else:
+            console.print("[bold yellow]No query provided. Exiting.[/bold yellow]")
+
+if __name__ == "__main__":
+    app()

janito-0.9.0/janito/callbacks.py

@@ -0,0 +1,130 @@
+"""
+Callback functions for tool execution in janito.
+"""
+
+from typing import Dict, Any, Tuple
+from rich.console import Console
+from rich.markdown import Markdown
+
+from janito.config import get_config
+from janito.tools import find_files
+from janito.tools.str_replace_editor.editor import str_replace_editor
+from janito.tools.delete_file import delete_file
+from janito.tools.search_text import search_text
+from janito.tools.decorators import format_tool_label
+
+def pre_tool_callback(tool_name: str, tool_input: Dict[str, Any], preamble_text: str = "") -> Tuple[Dict[str, Any], bool]:
+    """
+    Callback function that runs before a tool is executed.
+    
+    Args:
+        tool_name: Name of the tool being called
+        tool_input: Input parameters for the tool
+        preamble_text: Any text generated before the tool call
+        
+    Returns:
+        Tuple of (modified tool input, whether to cancel the tool call)
+    """
+    console = Console()
+    
+    # Add debug counter only when debug mode is enabled
+    if get_config().debug_mode:
+        if not hasattr(pre_tool_callback, "counter"):
+            pre_tool_callback.counter = 1
+        console.print(f"[bold yellow]DEBUG: Starting tool call #{pre_tool_callback.counter}[/bold yellow]")
+        pre_tool_callback.counter += 1
+    
+    # Print preamble text with enhanced markdown support if provided
+    if preamble_text:
+        # Use a single print statement to avoid extra newlines
+        console.print("[bold magenta]Janito:[/bold magenta] ", Markdown(preamble_text, code_theme="monokai"), end="")
+    
+    # Try to find the tool function
+    tool_func = None
+    for tool in [find_files, str_replace_editor, delete_file, search_text]:
+        if tool.__name__ == tool_name:
+            tool_func = tool
+            break
+    
+    # Create a copy of tool_input to modify for display
+    display_input = {}
+    
+    # Maximum length for string values
+    max_length = 50
+    
+    # Trim long string values for display
+    for key, value in tool_input.items():
+        if isinstance(value, str) and len(value) > max_length:
+            # For long strings, show first and last part with ellipsis in between
+            display_input[key] = f"{value[:20]}...{value[-20:]}" if len(value) > 45 else value[:max_length] + "..."
+        else:
+            display_input[key] = value
+    
+    # If we found the tool and it has a tool_meta label, use that for display
+    if tool_func:
+        formatted_label = format_tool_label(tool_func, tool_input)
+        if formatted_label:
+            console.print("[bold cyan]  Tool:[/bold cyan]", formatted_label, end=" → ")
+        else:
+            console.print("[bold cyan]  Tool:[/bold cyan]", f"{tool_name} {display_input}", end=" → ")
+    
+    return tool_input, True  # Continue with the tool call
+
+def post_tool_callback(tool_name: str, tool_input: Dict[str, Any], result: Any) -> Any:
+    """
+    Callback function that runs after a tool is executed.
+    
+    Args:
+        tool_name: Name of the tool that was called
+        tool_input: Input parameters for the tool
+        result: Result of the tool call
+        
+    Returns:
+        Modified result
+    """
+    console = Console()
+    
+    # Add debug counter only when debug mode is enabled
+    if get_config().debug_mode:
+        if not hasattr(post_tool_callback, "counter"):
+            post_tool_callback.counter = 1
+        console.print(f"[bold green]DEBUG: Completed tool call #{post_tool_callback.counter}[/bold green]")
+        post_tool_callback.counter += 1
+    
+    # Extract the last line of the result
+    if isinstance(result, tuple) and len(result) >= 1:
+        content, is_error = result
+        # Define prefix icon based on is_error
+        icon_prefix = "❌ " if is_error else "✅ "
+        
+        if isinstance(content, str):
+            # For find_files, extract just the count from the last line
+            if tool_name == "find_files" and content.count("\n") > 0:
+                lines = content.strip().split('\n')
+                if lines and lines[-1].isdigit():
+                    console.print(f"{icon_prefix}{lines[-1]}")
+                else:
+                    # Get the last line
+                    last_line = content.strip().split('\n')[-1]
+                    console.print(f"{icon_prefix}{last_line}")
+            else:
+                # For other tools, just get the last line
+                if '\n' in content:
+                    last_line = content.strip().split('\n')[-1]
+                    console.print(f"{icon_prefix}{last_line}")
+                else:
+                    console.print(f"{icon_prefix}{content}")
+        else:
+            console.print(f"{icon_prefix}{content}")
+    else:
+        # If result is not a tuple, convert to string and get the last line
+        result_str = str(result)
+        # Default to success icon when no error status is available
+        icon_prefix = "✅ "
+        if '\n' in result_str:
+            last_line = result_str.strip().split('\n')[-1]
+            console.print(f"{icon_prefix}{last_line}")
+        else:
+            console.print(f"{icon_prefix}{result_str}")
+    
+    return result

janito-0.9.0/janito/cli.py

@@ -0,0 +1,202 @@
+"""
+CLI functionality for the janito tool.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich import print as rprint
+import claudine
+from claudine.exceptions import MaxTokensExceededException, MaxRoundsExceededException
+
+from janito.config import get_config
+from janito.tools import find_files
+from janito.tools.str_replace_editor.editor import str_replace_editor
+from janito.tools.delete_file import delete_file
+from janito.tools.search_text import search_text
+from janito.callbacks import pre_tool_callback, post_tool_callback
+
+app = typer.Typer(help="Janito CLI tool")
+
+@app.command()
+def hello(name: str = typer.Argument("World", help="Name to greet")):
+    """
+    Say hello to someone.
+    """
+    rprint(f"[bold green]Hello {name}[/bold green]")
+    
+
+
+def debug_tokens(agent):
+    """
+    Display detailed token usage and pricing information.
+    """
+    from claudine.token_tracking import MODEL_PRICING, DEFAULT_MODEL
+    
+    console = Console()
+    usage = agent.get_token_usage()
+    text_usage = usage.text_usage
+    tools_usage = usage.tools_usage
+    total_usage = usage.total_usage
+    
+    # Get the pricing model
+    pricing = MODEL_PRICING.get(DEFAULT_MODEL)
+    
+    # Calculate costs manually
+    text_input_cost = pricing.input_tokens.calculate_cost(text_usage.input_tokens)
+    text_output_cost = pricing.output_tokens.calculate_cost(text_usage.output_tokens)
+    tools_input_cost = pricing.input_tokens.calculate_cost(tools_usage.input_tokens)
+    tools_output_cost = pricing.output_tokens.calculate_cost(tools_usage.output_tokens)
+    
+    # Format costs
+    format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
+    
+    console.print("\n[bold blue]Detailed Token Usage:[/bold blue]")
+    console.print(f"Text Input tokens: {text_usage.input_tokens}")
+    console.print(f"Text Output tokens: {text_usage.output_tokens}")
+    console.print(f"Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens}")
+    console.print(f"Tool Input tokens: {tools_usage.input_tokens}")
+    console.print(f"Tool Output tokens: {tools_usage.output_tokens}")
+    console.print(f"Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens}")
+    console.print(f"Total tokens: {total_usage.input_tokens + total_usage.output_tokens}")
+    
+    console.print("\n[bold blue]Pricing Information:[/bold blue]")
+    console.print(f"Input pricing: ${pricing.input_tokens.cost_per_million_tokens}/million tokens")
+    console.print(f"Output pricing: ${pricing.output_tokens.cost_per_million_tokens}/million tokens")
+    console.print(f"Text Input cost: {format_cost(text_input_cost)}")
+    console.print(f"Text Output cost: {format_cost(text_output_cost)}")
+    console.print(f"Text Total cost: {format_cost(text_input_cost + text_output_cost)}")
+    console.print(f"Tool Input cost: {format_cost(tools_input_cost)}")
+    console.print(f"Tool Output cost: {format_cost(tools_output_cost)}")
+    console.print(f"Tool Total cost: {format_cost(tools_input_cost + tools_output_cost)}")
+    console.print(f"Total cost: {format_cost(text_input_cost + text_output_cost + tools_input_cost + tools_output_cost)}")
+
+    # Display per-tool breakdown if available
+    if usage.by_tool:
+        console.print("\n[bold blue]Per-Tool Breakdown:[/bold blue]")
+        for tool_name, tool_usage in usage.by_tool.items():
+            tool_input_cost = pricing.input_tokens.calculate_cost(tool_usage.input_tokens)
+            tool_output_cost = pricing.output_tokens.calculate_cost(tool_usage.output_tokens)
+            console.print(f"   Tool: {tool_name}")
+            console.print(f"  Input tokens: {tool_usage.input_tokens}")
+            console.print(f"  Output tokens: {tool_usage.output_tokens}")
+            console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens}")
+            console.print(f"  Total cost: {format_cost(tool_input_cost + tool_output_cost)}")
+
+def process_query(query: str, debug: bool, verbose: bool):
+    """
+    Process a query using the claudine agent.
+    """
+    console = Console()
+    
+    # Get API key from environment variable or ask the user
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        console.print("[bold yellow]Warning:[/bold yellow] ANTHROPIC_API_KEY environment variable not set.")
+        console.print("Please set it or provide your API key now:")
+        api_key = typer.prompt("Anthropic API Key", hide_input=True)
+    
+    # Load instructions from file
+    import importlib.resources as pkg_resources
+    try:
+        # For Python 3.9+
+        try:
+            from importlib.resources import files
+            instructions = files('janito.data').joinpath('instructions.txt').read_text()
+        # Fallback for older Python versions
+        except (ImportError, AttributeError):
+            instructions = pkg_resources.read_text('janito.data', 'instructions.txt')
+        instructions = instructions.strip()
+    except Exception as e:
+        console.print(f"[bold yellow]Warning:[/bold yellow] Could not load instructions file: {str(e)}")
+        console.print("[dim]Using default instructions instead.[/dim]")
+        instructions = "You are a helpful AI assistant. Answer the user's questions to the best of your ability."
+           
+    # Initialize the agent with the tools
+    agent = claudine.Agent(
+        api_key=api_key,
+        tools=[
+            delete_file,
+            find_files,
+            search_text
+        ],
+        text_editor_tool=str_replace_editor,
+        tool_callbacks=(pre_tool_callback, post_tool_callback),
+        max_tokens=4096,
+        temperature=0.7,
+        instructions=instructions,
+        debug_mode=debug  # Enable debug mode
+    )
+    
+    # Process the query
+    console.print(f"[bold blue]Query:[/bold blue] {query}")
+    console.print("[bold blue]Generating response...[/bold blue]")
+    
+    try:
+        response = agent.process_prompt(query)
+        
+        console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
+        # Use rich's enhanced Markdown rendering for the response
+        console.print(Markdown(response, code_theme="monokai"))
+        
+    except MaxTokensExceededException as e:
+        # Display the partial response if available
+        if e.response_text:
+            console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
+            console.print(Markdown(e.response_text, code_theme="monokai"))
+        
+        console.print("\n[bold red]Error:[/bold red] Response was truncated because it reached the maximum token limit.")
+        console.print("[dim]Consider increasing the max_tokens parameter or simplifying your query.[/dim]")
+        
+    except MaxRoundsExceededException as e:
+        # Display the final response if available
+        if e.response_text:
+            console.print("\n[bold magenta]Janito:[/bold magenta] ", end="")
+            console.print(Markdown(e.response_text, code_theme="monokai"))
+        
+        console.print(f"\n[bold red]Error:[/bold red] Maximum number of tool execution rounds ({e.rounds}) reached. Some tasks may be incomplete.")
+        console.print("[dim]Consider increasing the max_rounds parameter or breaking down your task into smaller steps.[/dim]")
+    
+    # Show token usage
+    usage = agent.get_token_usage()
+    text_usage = usage.text_usage
+    tools_usage = usage.tools_usage
+    
+    if verbose:
+        debug_tokens(agent)
+    else:
+        total_tokens = text_usage.input_tokens + text_usage.output_tokens + tools_usage.input_tokens + tools_usage.output_tokens
+        cost_info = agent.get_cost()
+        cost_display = cost_info.format_total_cost() if hasattr(cost_info, 'format_total_cost') else ""
+        # Consolidated tokens and cost in a single line with a ruler
+        console.print(Rule(f"Tokens: {total_tokens} | Cost: {cost_display}", style="dim", align="center"))
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, 
+         query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
+         debug: bool = typer.Option(False, "--debug", "-d", help="Enable debug mode"),
+         verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed token usage and pricing information"),
+         workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory")):
+    """
+    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
+    """    
+    console = Console()
+    
+    # Set debug mode in config
+    get_config().debug_mode = debug
+    
+    if workspace:
+        try:
+            print(f"Setting workspace directory to: {workspace}")
+            get_config().workspace_dir = workspace
+            print(f"Workspace directory set to: {get_config().workspace_dir}")
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+            sys.exit(1)
+            
+    if ctx.invoked_subcommand is None and query:
+        process_query(query, debug, verbose)