janito 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

janito/__init__.py

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

janito/__main__.py

@@ -1,128 +1,151 @@
+"""
+Main entry point for the janito CLI.
+"""
+
 import typer
-from typing import Optional, List, Set
+import os
+import sys
 from pathlib import Path
-from rich.text import Text
-from rich import print as rich_print
+from typing import Optional, Dict, Any, List
 from rich.console import Console
-from .version import get_version
-
-from janito.config import config
-from janito.workspace import workset
-from janito.workspace.models import ScanType  # Add this import
-from .cli.commands import (
-    handle_request, handle_ask, 
-    handle_scan
-)
-
-
-app = typer.Typer(pretty_exceptions_enable=False)
-
-# Initialize console for CLI output
-console = Console()
-
-
-
-def typer_main(
-    user_request: Optional[str] = typer.Argument(None, help="User request"),
-    workspace_dir: Optional[Path] = typer.Option(None, "-w", "--workspace_dir", help="Working directory", file_okay=False, dir_okay=True),
-    debug: bool = typer.Option(False, "--debug", help="Show debug information"),
-    verbose: bool = typer.Option(False, "--verbose", help="Show verbose output"),
-    include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include"),
-    ask: bool = typer.Option(False, "--ask", help="Treat the request as a question about the codebase"),
-    play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
-    replay: bool = typer.Option(False, "--replay", help="Trigger the replay response flow"),
-    scan: bool = typer.Option(False, "--scan", help="Preview files that would be analyzed"),
-    version: bool = typer.Option(False, "--version", help="Show version information"),
-    test_cmd: Optional[str] = typer.Option(None, "--test", help="Command to run tests after changes"),
-    auto_apply: bool = typer.Option(False, "--auto-apply", help="Apply changes without confirmation"),
-    recursive: Optional[List[Path]] = typer.Option(None, "-r", "--recursive", help="Paths to scan recursively (directories only)"),
-    skip_work: bool = typer.Option(False, "-s", "--skip-work", help="Skip scanning workspace_dir when using include paths"),
-):
-    """Janito - AI-powered code modification assistant"""
-    if version:
-        console.print(f"Janito version {get_version()}")
-        return
-
-    # Check if workspace directory exists and handle creation
-    if workspace_dir and not workspace_dir.exists():
-        create = typer.confirm(f"\nWorkspace directory '{workspace_dir}' does not exist. Create it?")
-        if create:
+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:
-                workspace_dir.mkdir(parents=True)
-                console.print(f"[green]Created workspace directory: {workspace_dir}[/green]")
+                # 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:
-                error_text = Text(f"\nError: Failed to create workspace directory: {e}", style="red")
-                rich_print(error_text)
-                raise typer.Exit(1)
+                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:
-            error_text = Text("\nError: Workspace directory does not exist and was not created", style="red")
-            rich_print(error_text)
-            raise typer.Exit(1)
-
-    # Configure workspace
-    config.set_workspace_dir(workspace_dir)
-    config.set_debug(debug)
-    config.set_verbose(verbose)
-    config.set_auto_apply(auto_apply)
-
-    # Configure workset with scan paths
-    if include:
-        if config.debug:
-            Console(stderr=True).print("[cyan]Debug: Processing include paths...[/cyan]")
-        for path in include:
-            full_path = config.workspace_dir / path
-            if not full_path.resolve().is_relative_to(config.workspace_dir):
-                error_text = Text(f"\nError: Path must be within workspace: {path}", style="red")
-                rich_print(error_text)
-                raise typer.Exit(1)
-            workset.add_scan_path(path, ScanType.PLAIN)
-
-    if recursive:
-        if config.debug:
-            Console(stderr=True).print("[cyan]Debug: Processing recursive paths...[/cyan]")
-        for path in recursive:
-            full_path = config.workspace_dir / path
-            if not path.is_dir():
-                error_text = Text(f"\nError: Recursive path must be a directory: {path} ", style="red")
-                rich_print(error_text)
-                raise typer.Exit(1)
-            if not full_path.resolve().is_relative_to(config.workspace_dir):
-                error_text = Text(f"\nError: Path must be within workspace: {path}", style="red")
-                rich_print(error_text)
-                raise typer.Exit(1)
-            workset.add_scan_path(path, ScanType.RECURSIVE)
-
-    # Validate skip_work usage
-    if skip_work:
-        # Check if any include or recursive paths are provided
-        if not include and not recursive:
-            error_text = Text("\nError: --skip-work requires at least one include path (-i or -r)", style="red")
-            rich_print(error_text)
-            raise typer.Exit(1)
-        # Remove root path from workset when skip_work is enabled
-        workset._scan_paths = [p for p in workset._scan_paths if p.path != Path(".")]
-
-    if test_cmd:
-        config.set_test_cmd(test_cmd)
-
-    # Refresh workset content before handling commands
-    workset.refresh()
-
-    if ask:
-        if not user_request:
-            error_text = Text("\nError: No question provided. Please provide a question as the main argument when using --ask", style="red")
-            rich_print(error_text)
-            raise typer.Exit(1)
-        handle_ask(user_request)
-    elif play:
-        handle_play(play)
-    elif scan:
-        handle_scan()
-    else:
-        handle_request(user_request, replay=replay)
-
-def main():
-    typer.run(typer_main)
+            console.print("[bold yellow]No query provided. Exiting.[/bold yellow]")
 
 if __name__ == "__main__":
-    main()
+    app()

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/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)