todo-agent 0.3.2__py3-none-any.whl → 0.3.5__py3-none-any.whl

todo_agent/infrastructure/todo_shell.py

@@ -32,13 +32,19 @@ class TodoShell:
         self.todo_dir = os.path.dirname(todo_file_path) or os.getcwd()
         self.logger = logger
 
-    def execute(self, command: List[str], cwd: Optional[str] = None) -> str:
+    def execute(
+        self,
+        command: List[str],
+        cwd: Optional[str] = None,
+        suppress_color: bool = False,
+    ) -> str:
         """
-        Execute todo.sh command.
+        Execute a todo.sh command and return the output.
 
         Args:
             command: List of command arguments
             cwd: Working directory (defaults to todo.sh directory)
+            suppress_color: If True, strip ANSI color codes from output (for LLM consumption)
 
         Returns:
             Command output as string
@@ -52,6 +58,7 @@ class TodoShell:
             self.logger.debug(f"=== RAW COMMAND EXECUTION ===")
             self.logger.debug(f"Raw command: {raw_command}")
             self.logger.debug(f"Working directory: {cwd or self.todo_dir}")
+            self.logger.debug(f"Suppress color: {suppress_color}")
 
         try:
             working_dir = cwd or self.todo_dir
@@ -67,7 +74,20 @@ class TodoShell:
                 self.logger.debug(f"Raw stderr: {result.stderr}")
                 self.logger.debug(f"Return code: {result.returncode}")
 
-            return result.stdout.strip()
+            output = result.stdout.strip()
+
+            # Strip ANSI color codes if requested (for LLM consumption)
+            if suppress_color:
+                from rich.text import Text
+
+                # Use Rich's Text.from_ansi to parse and then get plain text
+                output = Text.from_ansi(output).plain
+                if self.logger:
+                    self.logger.debug(
+                        f"Stripped ANSI codes from output for LLM consumption"
+                    )
+
+            return output
         except subprocess.CalledProcessError as e:
             # Log error details
             if self.logger:
@@ -88,12 +108,18 @@ class TodoShell:
         """Add new task."""
         return self.execute(["todo.sh", "add", description])
 
-    def list_tasks(self, filter_str: Optional[str] = None) -> str:
+    def addto(self, destination: str, text: str) -> str:
+        """Add text to a specific file in the todo.txt directory."""
+        return self.execute(["todo.sh", "addto", destination, text])
+
+    def list_tasks(
+        self, filter_str: Optional[str] = None, suppress_color: bool = True
+    ) -> str:
         """List tasks with optional filtering."""
         command = ["todo.sh", "ls"]
         if filter_str:
             command.append(filter_str)
-        return self.execute(command)
+        return self.execute(command, suppress_color=suppress_color)
 
     def complete(self, task_number: int) -> str:
         """Mark task complete."""
@@ -135,20 +161,22 @@ class TodoShell:
         """Remove task priority."""
         return self.execute(["todo.sh", "depri", str(task_number)])
 
-    def list_projects(self) -> str:
+    def list_projects(self, suppress_color: bool = True) -> str:
         """List projects."""
-        return self.execute(["todo.sh", "lsp"])
+        return self.execute(["todo.sh", "lsp"], suppress_color=suppress_color)
 
-    def list_contexts(self) -> str:
+    def list_contexts(self, suppress_color: bool = True) -> str:
         """List contexts."""
-        return self.execute(["todo.sh", "lsc"])
+        return self.execute(["todo.sh", "lsc"], suppress_color=suppress_color)
 
-    def list_completed(self, filter_str: Optional[str] = None) -> str:
+    def list_completed(
+        self, filter_str: Optional[str] = None, suppress_color: bool = True
+    ) -> str:
         """List completed tasks with optional filtering."""
         command = ["todo.sh", "listfile", "done.txt"]
         if filter_str:
             command.append(filter_str)
-        return self.execute(command)
+        return self.execute(command, suppress_color=suppress_color)
 
     def archive(self) -> str:
         """Archive completed tasks."""
@@ -252,6 +280,61 @@ class TodoShell:
         # Replace the task with the new description
         return self.replace(task_number, new_description)
 
+    def set_parent(self, task_number: int, parent_number: Optional[int]) -> str:
+        """
+        Set or update parent task number for a task by intelligently rewriting it.
+
+        Args:
+            task_number: The task number to modify
+            parent_number: Parent task number, or None to remove parent
+
+        Returns:
+            The updated task description
+        """
+        # First, get the current task to parse its components
+        tasks_output = self.list_tasks()
+        task_lines = tasks_output.strip().split("\n")
+
+        # Find the task by its actual number (not array index)
+        current_task = None
+        for line in task_lines:
+            if line.strip():
+                # Extract task number from the beginning of the line (handling ANSI codes)
+                extracted_number = self._extract_task_number(line)
+                if extracted_number == task_number:
+                    current_task = line
+                    break
+
+        if not current_task:
+            raise TodoShellError(f"Task number {task_number} not found")
+
+        # Parse the current task components
+        components = self._parse_task_components(current_task)
+
+        # Update the parent (None removes it)
+        if parent_number is not None:
+            if not isinstance(parent_number, int) or parent_number <= 0:
+                raise TodoShellError(
+                    f"Invalid parent_number '{parent_number}'. Must be a positive integer."
+                )
+            parent_tag = f"parent:{parent_number}"
+            # Remove any existing parent tag and add the new one
+            components["other_tags"] = [
+                tag for tag in components["other_tags"] if not tag.startswith("parent:")
+            ]
+            components["other_tags"].append(parent_tag)
+        else:
+            # Remove parent tag
+            components["other_tags"] = [
+                tag for tag in components["other_tags"] if not tag.startswith("parent:")
+            ]
+
+        # Reconstruct the task
+        new_description = self._reconstruct_task(components)
+
+        # Replace the task with the new description
+        return self.replace(task_number, new_description)
+
     def _extract_task_number(self, line: str) -> Optional[int]:
         """
         Extract task number from a line that may contain ANSI color codes.

todo_agent/interface/cli.py

@@ -2,8 +2,9 @@
 Command-line interface for todo.sh LLM agent.
 """
 
-from typing import Optional
 import readline
+from typing import Optional
+
 from rich.align import Align
 from rich.console import Console, Group
 from rich.live import Live
@@ -23,8 +24,8 @@ try:
         TableFormatter,
         TaskFormatter,
     )
-    from todo_agent.interface.tools import ToolCallHandler
     from todo_agent.interface.progress import ToolCallProgress
+    from todo_agent.interface.tools import ToolCallHandler
 except ImportError:
     from core.todo_manager import TodoManager  # type: ignore[no-redef]
     from infrastructure.config import Config  # type: ignore[no-redef]
@@ -38,8 +39,8 @@ except ImportError:
         TableFormatter,
         TaskFormatter,
     )
-    from interface.tools import ToolCallHandler  # type: ignore[no-redef]
     from interface.progress import ToolCallProgress  # type: ignore[no-redef]
+    from interface.tools import ToolCallHandler  # type: ignore[no-redef]
 
 
 class CLI:
@@ -100,22 +101,23 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
-    def _create_tool_call_spinner(self, progress_description: str, 
-                                 sequence: int = 0, total_sequences: int = 0) -> Group:
+    def _create_tool_call_spinner(
+        self, progress_description: str, sequence: int = 0, total_sequences: int = 0
+    ) -> Group:
         """
         Create a multi-line spinner showing tool call progress.
-        
+
         Args:
             progress_description: User-friendly description of what the tool is doing
             sequence: Current sequence number
             total_sequences: Total number of sequences
-            
+
         Returns:
             Group object with spinner and optional sequence info
         """
         # Line 1: Main progress with spinner
         main_line = Spinner("dots", text=Text(progress_description, style="cyan"))
-        
+
         # Line 2: Sequence progress (show current sequence even if we don't know total)
         # if sequence > 0:
         #     if total_sequences > 0:
@@ -123,75 +125,87 @@ class CLI:
         #     else:
         #         sequence_text = Text(f"Sequence {sequence}", style="dim")
         #     return Group(main_line, sequence_text)
-        
-        return main_line
+
+        return Group(main_line)
 
     def _create_completion_spinner(self, thinking_time: float) -> Spinner:
         """
         Create completion spinner with timing.
-        
+
         Args:
             thinking_time: Total thinking time in seconds
-            
+
         Returns:
             Spinner object showing completion
         """
-        return Spinner("dots", text=Text(f"✅ Complete ({thinking_time:.1f}s)", style="green"))
+        return Spinner(
+            "dots", text=Text(f"✅ Complete ({thinking_time:.1f}s)", style="green")
+        )
 
     def _create_cli_progress_callback(self, live_display: Live) -> ToolCallProgress:
         """
         Create a CLI-specific progress callback for tool call tracking.
-        
+
         Args:
             live_display: The live display to update
-            
+
         Returns:
             ToolCallProgress implementation for CLI
         """
+
         class CLIProgressCallback(ToolCallProgress):
             def __init__(self, cli: CLI, live: Live):
                 self.cli = cli
                 self.live = live
                 self.current_sequence = 0
                 self.total_sequences = 0
-            
+
             def on_thinking_start(self) -> None:
                 """Show initial thinking spinner."""
-                spinner = self.cli._create_thinking_spinner("🤔 Analyzing your request...")
+                spinner = self.cli._create_thinking_spinner(
+                    "🤔 Analyzing your request..."
+                )
                 self.live.update(spinner)
-            
-            def on_tool_call_start(self, tool_name: str, progress_description: str,
-                                 sequence: int, total_sequences: int) -> None:
+
+            def on_tool_call_start(
+                self,
+                tool_name: str,
+                progress_description: str,
+                sequence: int,
+                total_sequences: int,
+            ) -> None:
                 """Show tool execution progress."""
                 self.current_sequence = sequence
                 self.total_sequences = total_sequences
-                
+
                 # Create multi-line spinner
                 spinner = self.cli._create_tool_call_spinner(
                     progress_description=progress_description,
                     sequence=sequence,
-                    total_sequences=total_sequences
+                    total_sequences=total_sequences,
                 )
                 self.live.update(spinner)
-            
-            def on_tool_call_complete(self, tool_name: str, success: bool, duration: float) -> None:
+
+            def on_tool_call_complete(
+                self, tool_name: str, success: bool, duration: float
+            ) -> None:
                 """Tool completion - no action needed."""
                 pass
-            
+
             def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
                 """Show sequence completion."""
                 spinner = self.cli._create_tool_call_spinner(
                     progress_description=f"🔄 Sequence {sequence} complete",
                     sequence=sequence,
-                    total_sequences=total_sequences
+                    total_sequences=total_sequences,
                 )
                 self.live.update(spinner)
-            
+
             def on_thinking_complete(self, total_time: float) -> None:
                 """Show completion spinner."""
                 spinner = self.cli._create_completion_spinner(total_time)
                 self.live.update(spinner)
-        
+
         return CLIProgressCallback(self, live_display)
 
     def _print_header(self) -> None:
@@ -296,7 +310,8 @@ class CLI:
                 if user_input.lower() == "list":
                     self.logger.debug("User requested task list")
                     try:
-                        output = self.todo_shell.list_tasks()
+                        # Use suppress_color=False for interactive display to preserve colors
+                        output = self.todo_shell.list_tasks(suppress_color=False)
                         formatted_output = TaskFormatter.format_task_list(output)
                         task_panel = PanelFormatter.create_task_panel(formatted_output)
                         self.console.print(task_panel)
@@ -311,7 +326,8 @@ class CLI:
                 if user_input.lower() == "done":
                     self.logger.debug("User requested completed task list")
                     try:
-                        output = self.todo_shell.list_completed()
+                        # Use suppress_color=False for interactive display to preserve colors
+                        output = self.todo_shell.list_completed(suppress_color=False)
                         formatted_output = TaskFormatter.format_completed_tasks(output)
                         task_panel = PanelFormatter.create_task_panel(
                             formatted_output, title="✅ Completed Tasks"
@@ -336,7 +352,7 @@ class CLI:
                 # Get memory usage
                 # DISABLED FOR NOW
                 memory_usage = self._get_memory_usage()
-                #memory_usage = None
+                # memory_usage = None
 
                 # Create response panel with memory usage
                 response_panel = PanelFormatter.create_response_panel(
@@ -368,9 +384,11 @@ class CLI:
             try:
                 # Create progress callback for tool call tracking
                 progress_callback = self._create_cli_progress_callback(live)
-                
+
                 # Process request through inference engine with progress tracking
-                response, thinking_time = self.inference.process_request(user_input, progress_callback)
+                response, thinking_time = self.inference.process_request(
+                    user_input, progress_callback
+                )
 
                 # Update spinner with completion message and thinking time
                 live.update(

todo_agent/interface/formatters.py

@@ -21,20 +21,23 @@ PROVIDER_ERROR_MESSAGES = {
     "rate_limit": "I'm a bit overwhelmed right now. Please wait a moment and try again, or type 'clear' to start fresh.",
     "auth_error": "I can't connect to my AI service. Please check your configuration, or type 'clear' to reset.",
     "timeout": "The request took too long. Please try again, or type 'clear' to reset our conversation.",
-    "general_error": "Something went wrong with my AI service. Please try again, or type 'clear' to reset our conversation."
+    "general_error": "Something went wrong with my AI service. Please try again, or type 'clear' to reset our conversation.",
 }
 
+
 def get_provider_error_message(error_type: str) -> str:
     """
     Get user-friendly error message for provider errors.
-    
+
     Args:
         error_type: The type of provider error
-        
+
     Returns:
         User-friendly error message with recovery suggestion
     """
-    return PROVIDER_ERROR_MESSAGES.get(error_type, PROVIDER_ERROR_MESSAGES["general_error"])
+    return PROVIDER_ERROR_MESSAGES.get(
+        error_type, PROVIDER_ERROR_MESSAGES["general_error"]
+    )
 
 
 class TaskFormatter:

todo_agent/interface/progress.py

@@ -3,34 +3,39 @@ Progress tracking interface for tool call execution.
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional
 
 
 class ToolCallProgress(ABC):
     """Abstract interface for tool call progress tracking."""
-    
+
     @abstractmethod
     def on_thinking_start(self) -> None:
         """Called when LLM starts thinking."""
         pass
-    
+
     @abstractmethod
-    def on_tool_call_start(self, tool_name: str, progress_description: str, 
-                          sequence: int, total_sequences: int) -> None:
+    def on_tool_call_start(
+        self,
+        tool_name: str,
+        progress_description: str,
+        sequence: int,
+        total_sequences: int,
+    ) -> None:
         """Called when a tool call starts."""
         pass
-    
+
     @abstractmethod
-    def on_tool_call_complete(self, tool_name: str, success: bool, 
-                             duration: float) -> None:
+    def on_tool_call_complete(
+        self, tool_name: str, success: bool, duration: float
+    ) -> None:
         """Called when a tool call completes (optional - no action needed)."""
         pass
-    
+
     @abstractmethod
     def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
         """Called when a tool call sequence completes."""
         pass
-    
+
     @abstractmethod
     def on_thinking_complete(self, total_time: float) -> None:
         """Called when thinking is complete."""
@@ -39,20 +44,26 @@ class ToolCallProgress(ABC):
 
 class NoOpProgress(ToolCallProgress):
     """No-operation implementation for when progress tracking is not needed."""
-    
+
     def on_thinking_start(self) -> None:
         pass
-    
-    def on_tool_call_start(self, tool_name: str, progress_description: str, 
-                          sequence: int, total_sequences: int) -> None:
+
+    def on_tool_call_start(
+        self,
+        tool_name: str,
+        progress_description: str,
+        sequence: int,
+        total_sequences: int,
+    ) -> None:
         pass
-    
-    def on_tool_call_complete(self, tool_name: str, success: bool, 
-                             duration: float) -> None:
+
+    def on_tool_call_complete(
+        self, tool_name: str, success: bool, duration: float
+    ) -> None:
         pass
-    
+
     def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
         pass
-    
+
     def on_thinking_complete(self, total_time: float) -> None:
         pass