tunacode-cli 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

tunacode/cli/repl.py

@@ -5,7 +5,12 @@ Interactive REPL (Read-Eval-Print Loop) implementation for TunaCode.
 Handles user input, command processing, and agent interaction in an interactive shell.
 """
 
+# ============================================================================
+# IMPORTS AND DEPENDENCIES
+# ============================================================================
+
 import json
+import logging
 import os
 import subprocess
 from asyncio.exceptions import CancelledError
@@ -15,21 +20,44 @@ from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.application.current import get_app
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 
-from tunacode.configuration.settings import ApplicationSettings
+from tunacode.constants import DEFAULT_CONTEXT_WINDOW
 from tunacode.core.agents import main as agent
 from tunacode.core.agents.main import patch_tool_messages
 from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.ui import console as ui
+from tunacode.ui.output import get_context_window_display
 from tunacode.ui.tool_ui import ToolUI
 from tunacode.utils.security import CommandSecurityError, safe_subprocess_run
 
 from ..types import CommandContext, CommandResult, StateManager, ToolArgs
 from .commands import CommandRegistry
 
-# Tool UI instance
+# ============================================================================
+# MODULE-LEVEL CONSTANTS AND CONFIGURATION
+# ============================================================================
+
 _tool_ui = ToolUI()
 
+MSG_OPERATION_ABORTED = "Operation aborted."
+MSG_OPERATION_ABORTED_BY_USER = "Operation aborted by user."
+MSG_TOOL_INTERRUPTED = "Tool execution was interrupted"
+MSG_REQUEST_CANCELLED = "Request cancelled"
+MSG_REQUEST_COMPLETED = "Request completed"
+MSG_JSON_RECOVERY = "Recovered using JSON tool parsing"
+MSG_SESSION_ENDED = "Session ended. Happy coding!"
+MSG_AGENT_BUSY = "Agent is busy, press Ctrl+C to interrupt."
+MSG_HIT_CTRL_C = "Hit Ctrl+C again to exit"
+SHELL_ENV_VAR = "SHELL"
+DEFAULT_SHELL = "bash"
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
 
 def _parse_args(args) -> ToolArgs:
     """
@@ -55,105 +83,63 @@ def _parse_args(args) -> ToolArgs:
         raise ValidationError(f"Invalid args type: {type(args)}")
 
 
-async def _tool_confirm(tool_call, node, state_manager: StateManager):
-    """Confirm tool execution with separated business logic and UI."""
-    # Create tool handler with state
-    tool_handler = ToolHandler(state_manager)
-    args = _parse_args(tool_call.args)
-
-    # Check if confirmation is needed
-    if not tool_handler.should_confirm(tool_call.tool_name):
-        # Log MCP tools when skipping confirmation
-        app_settings = ApplicationSettings()
-        if tool_call.tool_name not in app_settings.internal_tools:
-            title = _tool_ui._get_tool_title(tool_call.tool_name)
-            await _tool_ui.log_mcp(title, args)
-        return
-
-    # Stop spinner during user interaction (only if not streaming)
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.stop()
-
-    # Create confirmation request
-    request = tool_handler.create_confirmation_request(tool_call.tool_name, args)
-
-    # Show UI and get response
-    response = await _tool_ui.show_confirmation(request, state_manager)
+# ============================================================================
+# TOOL EXECUTION AND CONFIRMATION HANDLERS
+# ============================================================================
 
-    # Process the response
-    if not tool_handler.process_confirmation(response, tool_call.tool_name):
-        raise UserAbortError("User aborted.")
 
-    await ui.line()  # Add line after user input
-
-    # Restart spinner (only if not streaming)
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.start()
-
-
-async def _tool_handler(part, node, state_manager: StateManager):
+async def _tool_handler(part, state_manager: StateManager):
     """Handle tool execution with separated business logic and UI."""
-    # Create tool handler with state first to check if confirmation is needed
     tool_handler = ToolHandler(state_manager)
 
-    # Only show tool info for tools that require confirmation
     if tool_handler.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    # Stop spinner only if not streaming
     if not state_manager.session.is_streaming_active and state_manager.session.spinner:
         state_manager.session.spinner.stop()
 
-    # Track if we need to stop/restart streaming panel
     streaming_panel = None
     if state_manager.session.is_streaming_active and hasattr(
         state_manager.session, "streaming_panel"
     ):
         streaming_panel = state_manager.session.streaming_panel
-        # Stop the streaming panel to prevent UI interference during confirmation
         if streaming_panel and tool_handler.should_confirm(part.tool_name):
             await streaming_panel.stop()
 
     try:
         args = _parse_args(part.args)
 
-        # Use a synchronous function in run_in_terminal to avoid async deadlocks
         def confirm_func():
-            # Skip confirmation if not needed
             if not tool_handler.should_confirm(part.tool_name):
                 return False
-
-            # Create confirmation request
             request = tool_handler.create_confirmation_request(part.tool_name, args)
 
-            # Show sync UI and get response
             response = _tool_ui.show_sync_confirmation(request)
 
-            # Process the response
             if not tool_handler.process_confirmation(response, part.tool_name):
                 return True  # Abort
             return False  # Continue
 
-        # Run the confirmation in the terminal
         should_abort = await run_in_terminal(confirm_func)
 
         if should_abort:
             raise UserAbortError("User aborted.")
 
     except UserAbortError:
-        patch_tool_messages("Operation aborted by user.", state_manager)
+        patch_tool_messages(MSG_OPERATION_ABORTED_BY_USER, state_manager)
         raise
     finally:
-        # Restart streaming panel if it was stopped
         if streaming_panel and tool_handler.should_confirm(part.tool_name):
             await streaming_panel.start()
 
-        # Restart spinner only if not streaming
         if not state_manager.session.is_streaming_active and state_manager.session.spinner:
             state_manager.session.spinner.start()
 
 
-# Initialize command registry
+# ============================================================================
+# COMMAND SYSTEM
+# ============================================================================
+
 _command_registry = CommandRegistry()
 _command_registry.register_all_default_commands()
 
@@ -169,71 +155,138 @@ async def _handle_command(command: str, state_manager: StateManager) -> CommandR
     Returns:
         Command result (varies by command).
     """
-    # Create command context
     context = CommandContext(state_manager=state_manager, process_request=process_request)
 
     try:
-        # Set the process_request callback for commands that need it
         _command_registry.set_process_request_callback(process_request)
 
-        # Execute the command
         return await _command_registry.execute(command, context)
     except ValidationError as e:
         await ui.error(str(e))
 
 
+# ============================================================================
+# ERROR RECOVERY
+# ============================================================================
+
+
+async def _attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bool:
+    """
+    Attempt to recover from tool calling failures using guard clauses.
+
+    Returns:
+        bool: True if recovery was successful, False otherwise
+    """
+    error_str = str(e).lower()
+    tool_keywords = ["tool", "function", "call", "schema"]
+    if not any(keyword in error_str for keyword in tool_keywords):
+        return False
+
+    if not state_manager.session.messages:
+        return False
+
+    last_msg = state_manager.session.messages[-1]
+    if not hasattr(last_msg, "parts"):
+        return False
+
+    for part in last_msg.parts:
+        if not hasattr(part, "content") or not isinstance(part.content, str):
+            continue
+
+        try:
+            from tunacode.core.agents.main import extract_and_execute_tool_calls
+
+            def tool_callback_with_state(part, node):
+                return _tool_handler(part, state_manager)
+
+            await extract_and_execute_tool_calls(
+                part.content, tool_callback_with_state, state_manager
+            )
+
+            await ui.warning(f" {MSG_JSON_RECOVERY}")
+            return True
+
+        except Exception as e:
+            logger.debug(f"Failed to check triple quotes: {e}")
+            continue
+
+    return False
+
+
+# ============================================================================
+# AGENT OUTPUT DISPLAY
+# ============================================================================
+
+
+async def _display_agent_output(res, enable_streaming: bool) -> None:
+    """Display agent output using guard clauses to flatten nested conditionals."""
+    if enable_streaming:
+        return
+
+    if not hasattr(res, "result") or res.result is None or not hasattr(res.result, "output"):
+        await ui.muted(MSG_REQUEST_COMPLETED)
+        return
+
+    output = res.result.output
+
+    if not isinstance(output, str):
+        return
+
+    if output.strip().startswith('{"thought"'):
+        return
+
+    if '"tool_uses"' in output:
+        return
+
+    await ui.agent(output)
+
+
+# ============================================================================
+# MAIN AGENT REQUEST PROCESSING
+# ============================================================================
+
+
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
     """Process input using the agent, handling cancellation safely."""
+
     state_manager.session.spinner = await ui.spinner(
         True, state_manager.session.spinner, state_manager
     )
     try:
-        # Patch any orphaned tool calls from previous requests before proceeding
-        patch_tool_messages("Tool execution was interrupted", state_manager)
+        patch_tool_messages(MSG_TOOL_INTERRUPTED, state_manager)
 
-        # Clear tracking for new request when thoughts are enabled
         if state_manager.session.show_thoughts:
             state_manager.session.tool_calls = []
-            # Don't clear files_in_context - keep it cumulative for the session
             state_manager.session.iteration_count = 0
             state_manager.session.current_iteration = 0
 
-        # Track message start for thoughts display
         start_idx = len(state_manager.session.messages)
 
-        # Create a partial function that includes state_manager
         def tool_callback_with_state(part, node):
-            return _tool_handler(part, node, state_manager)
+            return _tool_handler(part, state_manager)
 
-        # Expand @file references before sending to the agent
         try:
             from tunacode.utils.text_utils import expand_file_refs
 
             text, referenced_files = expand_file_refs(text)
-            # Track the referenced files
             for file_path in referenced_files:
                 state_manager.session.files_in_context.add(file_path)
         except ValueError as e:
             await ui.error(str(e))
             return
 
-        # Check if streaming is enabled (default: True for better UX)
         enable_streaming = state_manager.session.user_config.get("settings", {}).get(
             "enable_streaming", True
         )
 
         if enable_streaming:
-            # Stop spinner before starting streaming display (Rich.Live conflict)
             await ui.spinner(False, state_manager.session.spinner, state_manager)
 
-            # Mark that streaming is active to prevent spinner conflicts
             state_manager.session.is_streaming_active = True
 
-            # Use streaming agent processing
             streaming_panel = ui.StreamingAgentPanel()
             await streaming_panel.start()
 
-            # Store streaming panel reference in session for tool handler access
             state_manager.session.streaming_panel = streaming_panel
 
             try:
@@ -250,11 +303,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 )
             finally:
                 await streaming_panel.stop()
-                # Clear streaming panel reference
                 state_manager.session.streaming_panel = None
-                # Mark streaming as inactive
                 state_manager.session.is_streaming_active = False
-                # Don't restart spinner - it will be stopped in the outer finally block anyway
         else:
             # Use normal agent processing
             res = await agent.process_request(
@@ -263,6 +313,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 state_manager,
                 tool_callback=tool_callback_with_state,
             )
+
         if output:
             if state_manager.session.show_thoughts:
                 new_msgs = state_manager.session.messages[start_idx:]
@@ -271,62 +322,38 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                         await ui.muted(f"THOUGHT: {msg['thought']}")
 
             # Only display result if not streaming (streaming already showed content)
-            if not enable_streaming:
-                # Check if result exists and has output
-                if (
-                    hasattr(res, "result")
-                    and res.result is not None
-                    and hasattr(res.result, "output")
-                ):
-                    output = res.result.output
-                    # Filter out JSON responses with "thought" field
-                    if isinstance(output, str) and not (
-                        output.strip().startswith('{"thought"') or '"tool_uses"' in output
-                    ):
-                        await ui.agent(output)
-                else:
-                    # Fallback: show that the request was processed
-                    await ui.muted("Request completed")
+            if enable_streaming:
+                pass  # Guard: streaming already showed content
+            elif (
+                not hasattr(res, "result")
+                or res.result is None
+                or not hasattr(res.result, "output")
+            ):
+                # Fallback: show that the request was processed
+                await ui.muted(MSG_REQUEST_COMPLETED)
+            else:
+                # Use the dedicated function for displaying agent output
+                await _display_agent_output(res, enable_streaming)
 
             # Always show files in context after agent response
             if state_manager.session.files_in_context:
-                # Extract just filenames from full paths for readability
                 filenames = [Path(f).name for f in sorted(state_manager.session.files_in_context)]
                 await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
+
+    # --- ERROR HANDLING ---
     except CancelledError:
-        await ui.muted("Request cancelled")
+        await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted("Operation aborted.")
+        await ui.muted(MSG_OPERATION_ABORTED)
     except UnexpectedModelBehavior as e:
         error_message = str(e)
         await ui.muted(error_message)
         patch_tool_messages(error_message, state_manager)
     except Exception as e:
-        # Check if this might be a tool calling failure that we can recover from
-        error_str = str(e).lower()
-        if any(keyword in error_str for keyword in ["tool", "function", "call", "schema"]):
-            # Try to extract and execute tool calls from the last response
-            if state_manager.session.messages:
-                last_msg = state_manager.session.messages[-1]
-                if hasattr(last_msg, "parts"):
-                    for part in last_msg.parts:
-                        if hasattr(part, "content") and isinstance(part.content, str):
-                            from tunacode.core.agents.main import extract_and_execute_tool_calls
+        # Try tool recovery for tool-related errors
+        if await _attempt_tool_recovery(e, state_manager):
+            return  # Successfully recovered
 
-                            try:
-                                # Create a partial function that includes state_manager
-                                def tool_callback_with_state(part, node):
-                                    return _tool_handler(part, node, state_manager)
-
-                                await extract_and_execute_tool_calls(
-                                    part.content, tool_callback_with_state, state_manager
-                                )
-                                await ui.warning(" Recovered using JSON tool parsing")
-                                return  # Successfully recovered
-                            except Exception:
-                                pass  # Fallback failed, continue with normal error handling
-
-        # Wrap unexpected exceptions in AgentError for better tracking
         agent_error = AgentError(f"Agent processing failed: {str(e)}")
         agent_error.__cause__ = e  # Preserve the original exception chain
         await ui.error(str(e))
@@ -334,20 +361,32 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         await ui.spinner(False, state_manager.session.spinner, state_manager)
         state_manager.session.current_task = None
 
-        # Force refresh of the multiline input prompt to restore placeholder
         if "multiline" in state_manager.session.input_sessions:
             await run_in_terminal(
                 lambda: state_manager.session.input_sessions["multiline"].app.invalidate()
             )
 
 
+# ============================================================================
+# MAIN REPL LOOP
+# ============================================================================
+
+
 async def repl(state_manager: StateManager):
+    """Main REPL loop that handles user interaction and input processing."""
     action = None
     ctrl_c_pressed = False
 
-    # Professional startup information
-    await ui.muted(f"• Model: {state_manager.session.current_model}")
-    await ui.success("Ready to assist with your development")
+    model_name = state_manager.session.current_model
+    max_tokens = (
+        state_manager.session.user_config.get("context_window_size") or DEFAULT_CONTEXT_WINDOW
+    )
+    state_manager.session.max_tokens = max_tokens
+
+    state_manager.session.update_token_count()
+    context_display = get_context_window_display(state_manager.session.total_tokens, max_tokens)
+    await ui.muted(f"• Model: {model_name} • {context_display}")
+    await ui.success("Ready to assist")
     await ui.line()
 
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
@@ -360,7 +399,7 @@ async def repl(state_manager: StateManager):
                 if ctrl_c_pressed:
                     break
                 ctrl_c_pressed = True
-                await ui.warning("Hit Ctrl+C again to exit")
+                await ui.warning(MSG_HIT_CTRL_C)
                 continue
 
             if not line:
@@ -380,16 +419,12 @@ async def repl(state_manager: StateManager):
             if line.startswith("!"):
                 command = line[1:].strip()
 
-                # Show tool-style header for bash commands
                 cmd_display = command if command else "Interactive shell"
                 await ui.panel("Tool(bash)", f"Command: {cmd_display}", border_style="yellow")
 
                 def run_shell():
                     try:
                         if command:
-                            # Use secure subprocess execution for shell commands
-                            # Note: User shell commands are inherently risky but this is by design
-                            # We validate but allow shell features since it's explicit user intent
                             try:
                                 result = safe_subprocess_run(
                                     command,
@@ -398,30 +433,64 @@ async def repl(state_manager: StateManager):
                                     capture_output=False,
                                 )
                                 if result.returncode != 0:
-                                    print(f"\nCommand exited with code {result.returncode}")
+                                    ui.console.print(
+                                        f"\nCommand exited with code {result.returncode}"
+                                    )
                             except CommandSecurityError as e:
-                                print(f"\nSecurity validation failed: {str(e)}")
-                                print("If you need to run this command, please ensure it's safe.")
+                                ui.console.print(f"\nSecurity validation failed: {str(e)}")
+                                ui.console.print(
+                                    "If you need to run this command, please ensure it's safe."
+                                )
                         else:
-                            shell = os.environ.get("SHELL", "bash")
+                            shell = os.environ.get(SHELL_ENV_VAR, DEFAULT_SHELL)
                             subprocess.run(shell)  # Interactive shell is safe
                     except Exception as e:
-                        print(f"\nShell command failed: {str(e)}")
+                        ui.console.print(f"\nShell command failed: {str(e)}")
 
                 await run_in_terminal(run_shell)
                 await ui.line()
                 continue
 
-            # Check if another task is already running
+            # --- AGENT REQUEST PROCESSING ---
             if state_manager.session.current_task and not state_manager.session.current_task.done():
-                await ui.muted("Agent is busy, press Ctrl+C to interrupt.")
+                await ui.muted(MSG_AGENT_BUSY)
                 continue
 
             state_manager.session.current_task = get_app().create_background_task(
                 process_request(line, state_manager)
             )
+            await state_manager.session.current_task
 
-    if action == "restart":
-        await repl(state_manager)
-    else:
-        await ui.info("Session ended. Happy coding!")
+            state_manager.session.update_token_count()
+            context_display = get_context_window_display(
+                state_manager.session.total_tokens, state_manager.session.max_tokens
+            )
+            await ui.muted(f"• Model: {state_manager.session.current_model} • {context_display}")
+
+        if action == "restart":
+            await repl(state_manager)
+        else:
+            # Show session cost summary if available
+            session_total = state_manager.session.session_total_usage
+            if session_total:
+                try:
+                    prompt = int(session_total.get("prompt_tokens", 0) or 0)
+                    completion = int(session_total.get("completion_tokens", 0) or 0)
+                    total_tokens = prompt + completion
+                    total_cost = float(session_total.get("cost", 0) or 0)
+
+                    # Only show summary if we have actual token usage
+                    if total_tokens > 0 or total_cost > 0:
+                        summary = (
+                            f"\n[bold cyan]TunaCode Session Summary[/bold cyan]\n"
+                            f"  - Total Tokens:      {total_tokens:,}\n"
+                            f"  - Prompt Tokens:     {prompt:,}\n"
+                            f"  - Completion Tokens: {completion:,}\n"
+                            f"  - [bold green]Total Session Cost: ${total_cost:.4f}[/bold green]"
+                        )
+                        ui.console.print(summary)
+                except (TypeError, ValueError) as e:
+                    # Skip displaying summary if values can't be converted to numbers
+                    logger.debug(f"Failed to display token usage summary: {e}")
+
+            await ui.info(MSG_SESSION_ENDED)

tunacode/configuration/defaults.py

@@ -23,6 +23,8 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,
         "fallback_verbosity": "normal",  # Options: minimal, normal, detailed
+        "context_window_size": 200000,
+        "use_dspy_optimization": True,  # Enable DSPy tool selection optimization
     },
     "mcpServers": {},
 }

tunacode/configuration/models.py

@@ -24,6 +24,9 @@ class ModelRegistry:
             "anthropic:claude-3-7-sonnet-latest": ModelConfig(
                 pricing=ModelPricing(input=3.00, cached_input=1.50, output=15.00)
             ),
+            "google/gemini-2.5-flash-lite-preview-06-17": ModelConfig(
+                pricing=ModelPricing(input=0.10, cached_input=0.025, output=0.40)
+            ),
             "google-gla:gemini-2.0-flash": ModelConfig(
                 pricing=ModelPricing(input=0.10, cached_input=0.025, output=0.40)
             ),
@@ -75,6 +78,9 @@ class ModelRegistry:
             "openrouter:openai/gpt-4.1-nano": ModelConfig(
                 pricing=ModelPricing(input=0.10, cached_input=0.05, output=0.40)
             ),
+            "openrouter:google/gemini-2.5-flash-lite-preview-06-17": ModelConfig(
+                pricing=ModelPricing(input=0.10, cached_input=0.025, output=0.40)
+            ),
         }
 
     def get_model(self, name: ModelName) -> ModelConfig:

tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.40"
+APP_VERSION = "0.0.42"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"
@@ -20,6 +20,7 @@ MAX_FILE_SIZE = 100 * 1024  # 100KB
 MAX_COMMAND_OUTPUT = 5000  # 5000 chars
 MAX_FILES_IN_DIR = 50
 MAX_TOTAL_DIR_SIZE = 2 * 1024 * 1024  # 2 MB
+DEFAULT_CONTEXT_WINDOW = 200000  # 200k tokens
 
 
 # Command output processing
@@ -36,6 +37,7 @@ TOOL_BASH = "bash"
 TOOL_GREP = "grep"
 TOOL_LIST_DIR = "list_dir"
 TOOL_GLOB = "glob"
+TOOL_TODO = "todo"
 
 # Tool categorization
 READ_ONLY_TOOLS = [TOOL_READ_FILE, TOOL_GREP, TOOL_LIST_DIR, TOOL_GLOB]
@@ -92,8 +94,8 @@ UI_COLORS = {
 }
 
 # UI text and formatting
-UI_PROMPT_PREFIX = "❯ "
-UI_THINKING_MESSAGE = "[bold #00d7ff]● Thinking...[/bold #00d7ff]"
+UI_PROMPT_PREFIX = "> "
+UI_THINKING_MESSAGE = "[bold #00d7ff]Thinking...[/bold #00d7ff]"
 UI_DARKGREY_OPEN = "<darkgrey>"
 UI_DARKGREY_CLOSE = "</darkgrey>"
 UI_BOLD_OPEN = "<bold>"
@@ -138,3 +140,25 @@ MSG_UPDATE_AVAILABLE = "Update available: v{latest_version}"
 MSG_UPDATE_INSTRUCTION = "Exit, and run: [bold]pip install --upgrade tunacode-cli"
 MSG_VERSION_DISPLAY = "TunaCode CLI {version}"
 MSG_FILE_SIZE_LIMIT = " Please specify a smaller file or use other tools to process it."
+
+# Todo-related constants
+TODO_STATUS_PENDING = "pending"
+TODO_STATUS_IN_PROGRESS = "in_progress"
+TODO_STATUS_COMPLETED = "completed"
+TODO_STATUSES = [TODO_STATUS_PENDING, TODO_STATUS_IN_PROGRESS, TODO_STATUS_COMPLETED]
+
+TODO_PRIORITY_HIGH = "high"
+TODO_PRIORITY_MEDIUM = "medium"
+TODO_PRIORITY_LOW = "low"
+TODO_PRIORITIES = [TODO_PRIORITY_HIGH, TODO_PRIORITY_MEDIUM, TODO_PRIORITY_LOW]
+
+# Maximum number of todos allowed per session
+MAX_TODOS_PER_SESSION = 100
+
+# Maximum length for todo content
+MAX_TODO_CONTENT_LENGTH = 500
+
+# JSON parsing retry configuration
+JSON_PARSE_MAX_RETRIES = 10
+JSON_PARSE_BASE_DELAY = 0.1  # Initial delay in seconds
+JSON_PARSE_MAX_DELAY = 5.0  # Maximum delay in seconds