todo-agent 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)
 
 __commit_id__ = commit_id = None

todo_agent/core/todo_manager.py

@@ -21,6 +21,39 @@ class TodoManager:
         due: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
+        # Validate and sanitize inputs
+        if priority and not (
+            len(priority) == 1 and priority.isalpha() and priority.isupper()
+        ):
+            raise ValueError(
+                f"Invalid priority '{priority}'. Must be a single uppercase letter (A-Z)."
+            )
+
+        if project:
+            # Remove any existing + symbols to prevent duplication
+            project = project.strip().lstrip("+")
+            if not project:
+                raise ValueError(
+                    "Project name cannot be empty after removing + symbol."
+                )
+
+        if context:
+            # Remove any existing @ symbols to prevent duplication
+            context = context.strip().lstrip("@")
+            if not context:
+                raise ValueError(
+                    "Context name cannot be empty after removing @ symbol."
+                )
+
+        if due:
+            # Basic date format validation
+            try:
+                datetime.strptime(due, "%Y-%m-%d")
+            except ValueError:
+                raise ValueError(
+                    f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
+                )
+
         # Build the full task description with priority, project, and context
         full_description = description
 

todo_agent/infrastructure/calendar_utils.py

@@ -0,0 +1,64 @@
+"""
+Calendar utilities for generating calendar output in system prompts.
+"""
+
+import calendar
+import subprocess
+from datetime import datetime, timedelta
+
+
+def get_calendar_output() -> str:
+    """
+    Generate calendar output for previous, current, and next month.
+
+    Returns:
+        Formatted calendar string showing three months side by side
+    """
+    try:
+        # Use cal -3 to get three months side by side
+        result = subprocess.run(
+            ["cal", "-3"], capture_output=True, text=True, check=True
+        )
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar module
+        return _get_python_cal_output()
+
+
+def _get_python_cal_output() -> str:
+    """
+    Generate calendar output using Python calendar module as fallback.
+
+    Returns:
+        Calendar output formatted similar to cal command
+    """
+    current_date = datetime.now()
+
+    # Calculate previous, current, and next month
+    prev_month = current_date - timedelta(days=current_date.day)
+    next_month = current_date.replace(day=1) + timedelta(days=32)
+    next_month = next_month.replace(day=1)
+
+    calendars = []
+
+    for date in [prev_month, current_date, next_month]:
+        cal = calendar.month(date.year, date.month)
+        calendars.append(cal.strip())
+
+    return "\n\n".join(calendars)
+
+
+def get_current_month_calendar() -> str:
+    """
+    Get calendar for current month only.
+
+    Returns:
+        Calendar output for current month
+    """
+    try:
+        result = subprocess.run(["cal"], capture_output=True, text=True, check=True)
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar
+        current_date = datetime.now()
+        return calendar.month(current_date.year, current_date.month).strip()

todo_agent/infrastructure/inference.py

@@ -75,6 +75,15 @@ class Inference:
 
         current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
+        # Get calendar output
+        from .calendar_utils import get_calendar_output
+
+        try:
+            calendar_output = get_calendar_output()
+        except Exception as e:
+            self.logger.warning(f"Failed to get calendar output: {e!s}")
+            calendar_output = "Calendar unavailable"
+
         # Load system prompt from file
         prompt_file_path = os.path.join(
             os.path.dirname(__file__), "prompts", "system_prompt.txt"
@@ -84,9 +93,11 @@ class Inference:
             with open(prompt_file_path, encoding="utf-8") as f:
                 system_prompt_template = f.read()
 
-            # Format the template with the tools section and current datetime
+            # Format the template with the tools section, current datetime, and calendar
             return system_prompt_template.format(
-                tools_section=tools_section, current_datetime=current_datetime
+                tools_section=tools_section,
+                current_datetime=current_datetime,
+                calendar_output=calendar_output,
             )
 
         except FileNotFoundError:

todo_agent/infrastructure/llm_client_factory.py

@@ -2,6 +2,8 @@
 Factory for creating LLM clients based on configuration.
 """
 
+# mypy: disable-error-code="no-redef"
+
 from typing import Optional
 
 try:
@@ -15,8 +17,8 @@ except ImportError:
     from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
     from infrastructure.logger import Logger  # type: ignore[no-redef]
     from infrastructure.ollama_client import OllamaClient  # type: ignore[no-redef]
-    from infrastructure.openrouter_client import (  # type: ignore[no-redef]
-        OpenRouterClient,
+    from infrastructure.openrouter_client import (
+        OpenRouterClient,  # type: ignore[no-redef, misc]
     )
 
 

todo_agent/infrastructure/ollama_client.py

@@ -72,6 +72,12 @@ class OllamaClient(LLMClient):
         if "message" in response and "tool_calls" in response["message"]:
             tool_calls = response["message"]["tool_calls"]
             self.logger.info(f"Response contains {len(tool_calls)} tool calls")
+            
+            # Log thinking content (response body) if present
+            content = response["message"].get("content", "")
+            if content and content.strip():
+                self.logger.info(f"LLM thinking before tool calls: {content}")
+            
             for i, tool_call in enumerate(tool_calls):
                 tool_name = tool_call.get("function", {}).get("name", "unknown")
                 self.logger.info(f"  Tool call {i + 1}: {tool_name}")

todo_agent/infrastructure/openrouter_client.py

@@ -78,6 +78,12 @@ class OpenRouterClient(LLMClient):
             if "message" in choice and "tool_calls" in choice["message"]:
                 tool_calls = choice["message"]["tool_calls"]
                 self.logger.info(f"Response contains {len(tool_calls)} tool calls")
+                
+                # Log thinking content (response body) if present
+                content = choice["message"].get("content", "")
+                if content and content.strip():
+                    self.logger.info(f"LLM thinking before tool calls: {content}")
+                
                 for i, tool_call in enumerate(tool_calls):
                     tool_name = tool_call.get("function", {}).get("name", "unknown")
                     self.logger.info(f"  Tool call {i + 1}: {tool_name}")

todo_agent/infrastructure/prompts/system_prompt.txt

@@ -1,40 +1,124 @@
 You are a todo.sh assistant managing tasks in standard todo.txt format.
 
 CURRENT DATE/TIME: {current_datetime}
+{calendar_output}
 
 CORE PRINCIPLES:
-1. **Strategic Tool Usage**: Batch discovery tools ([list_tasks, list_completed_tasks, list_projects, list_contexts]) to minimize API calls
-2. **Conversational**: Respond naturally without mentioning tools or technical details
-3. **Data Integrity**: Only reference tasks/projects/contexts returned by actual tool calls - NEVER hallucinate
-4. **Safety**: Always verify current state before modifications using list_tasks() and list_completed_tasks()
-5. **Todo.txt Compliance**: Use standard format and ordering
+1. Strategic Tool Usage: Batch discovery tools ([list_tasks, list_completed_tasks, list_projects, list_contexts]) to minimize API calls
+2. Conversational: Respond naturally without mentioning tools or technical details
+3. Data Integrity: Only reference tasks/projects/contexts returned by actual tool calls - NEVER hallucinate
+4. Safety: Always verify current state before modifications using list_tasks() and list_completed_tasks()
+5. Todo.txt Compliance: Use standard format and ordering
+6. Conciseness: Keep responses brief and to the point, especially for simple questions
+
+DEPENDENCY AWARENESS:
+- Identify and track task dependencies through project relationships and natural language analysis
+- When creating tasks, consider what other tasks might be prerequisites or blockers
+- Suggest dependency relationships when users add related tasks
+- Prioritize tasks based on dependency chains - complete prerequisites before dependent tasks
+- When completing tasks, identify and suggest next steps for dependent tasks
+- Use project tags to group related tasks and identify dependency clusters
+- Consider temporal dependencies (tasks that must happen in sequence) vs logical dependencies (tasks that require others to be done first)
+- When users ask "what should I do next?", prioritize tasks that unblock other work
+- Flag potential dependency conflicts or circular dependencies
+- Suggest breaking down complex tasks with multiple dependencies into smaller, manageable pieces
+
+TASK ORDERING & PRESENTATION:
+- Order: dependency → priority → effort
+- Complete quick wins first: 2-minute tasks immediately, <15min tasks early
+- Prioritize high-leverage tasks that unblock multiple dependent tasks
+- Group related tasks together (e.g., meal planning → grocery shopping → cooking)
+- Show clear dependency relationships: "After X, do Y because..."
+- Present tasks in logical sequences with clear next steps
+- Consider task size and energy requirements in the suggested order
+CRITICAL: When listing tasks, NEVER organize by due date alone. ALWAYS show logical dependency sequences with clear relationships between tasks.
 
 TODO.TXT FORMAT:
 - Priority: (A), (B), (C) • Completion: "x YYYY-MM-DD" • Creation: YYYY-MM-DD
-- Projects: +project • Contexts: @context • Due dates: due:YYYY-MM-DD
+- Projects: +project (single + symbol) • Contexts: @context (single @ symbol) • Due dates: due:YYYY-MM-DD
 - Example: "(A) 2024-01-15 Call dentist +health @phone due:2024-01-20"
+- CRITICAL: Never use double symbols like ++project or @@context - always use single + and @ symbols
 
 WORKFLOW:
-**Discovery First**: Gather context with batched tool calls before any action
-**Verify Before Action**: Check for duplicates, conflicts, or existing completions
-**Sequential Processing**: Tools execute in order within batches
+Discovery First: Gather context with batched tool calls before any action
+Verify Before Action: Check for duplicates, conflicts, or existing completions
+Sequential Processing: Tools execute in order within batches
+
+STRATEGIC THINKING & PROBLEM SOLVING:
+When approaching user requests, think strategically about the broader context and long-term implications:
+
+- **Problem Analysis**: What's the real underlying need? Is this a symptom of a larger issue?
+- **Strategic Context**: How does this request fit into the user's overall goals and workflow?
+- **Dependency Mapping**: What tasks might be blocking or enabled by this action?
+- **Resource Optimization**: What's the most efficient path to the desired outcome?
+- **Risk Assessment**: What could go wrong, and how can we mitigate it?
+- **Future-Proofing**: How will this decision impact future task management?
+
+Example strategic thinking:
+"Looking at this request strategically, I need to:
+1. Understand the current task landscape to identify dependencies and bottlenecks
+2. Consider how this action affects the overall project timeline and priorities
+3. Look for opportunities to optimize the workflow while addressing the immediate need
+4. Assess whether this is a one-off task or part of a larger pattern that needs systematic attention
+
+Let me gather the context to make an informed decision..."
 
-CONTEXT INFERENCE:
+TASK COMPLETION:
+When users say something like "I finished X" or "I'm done with Y", search for matching tasks
+using list_tasks() and handle ambiguity by showing numbered options. Always verify task
+hasn't already been completed with list_completed_tasks().
+
+COMPLETION INTELLIGENCE:
+- If user's statement clearly matches exactly one task (e.g., "I finished mowing the lawn" 
+  when there's only one task with "yard work" in the description), complete it immediately
+- If user's statement matches multiple tasks, show numbered options and ask for clarification
+- If user's statement is ambiguous or could match many tasks, ask for clarification
+- When in doubt about ambiguity, ask for more information to clarify intent before taking any action
+
+CONTEXT AND PROJECT INFERENCE:
 - Extract temporal urgency from due dates and creation dates
 - Identify task relationships through shared projects/contexts
 - Determine scope boundaries from natural language (work vs personal tasks)
 - Recognize priority patterns and dependencies
+- Analyze dependency chains within and across projects
+- Identify blocking tasks that prevent progress on dependent work
+- Suggest logical task sequences based on dependency relationships
+- Consider resource dependencies (time, tools, information) when prioritizing
+
+TASK CREATION INTELLIGENCE:
+- When users request to add a task, automatically infer appropriate projects, contexts, and due dates based on the task content
+- When intent is clear, create the task immediately without asking for confirmation
+- Only ask for clarification when project/context/due date is genuinely ambiguous
+- Use priority C for new tasks unless urgency is indicated
+- DUE DATE INFERENCE: Automatically infer due dates using multiple intelligence sources:
+  * Explicit expressions: "tomorrow", "next week", "next Monday", "by Friday" → Convert to YYYY-MM-DD format
+  * Relative expressions: "in 3 days", "next month", "end of month" → Calculate appropriate date
+  * Urgency indicators: "urgent", "asap", "today" → Set to today's date
+  * Vague expressions: "sometime this week" → Set to end of current week
+  * Task nature inference: Use common sense based on task type and existing patterns:
+    - Work tasks → Consider work week patterns and existing work task due dates
+    - Personal tasks → Consider weekend availability and personal schedule patterns
+    - Health/medical → Consider urgency and typical scheduling patterns
+    - Shopping/errands → Consider when items are needed and store hours
+    - Bills/payments → Consider due dates and late fees
+    - Maintenance tasks → Consider frequency patterns and current state
+  * Calendar context: Use current date/time and calendar output to inform timing decisions
+  * Existing task patterns: Look at similar tasks and their due dates for consistency
+  * Always infer: Every task should have a reasonable due date based on available context
 
 TASK ADVICE:
 Think deeply and critically to categorize tasks and suggest actions:
 - Consider real-life implications and importance to my responsibilities regardless of explicit priority
 - When users request prioritization help, use Eisenhower Matrix:
     Q1 (Urgent+Important: DO), Q2 (Important: SCHEDULE), Q3 (Urgent: DELEGATE), Q4 (Neither: ELIMINATE) [assign SPARINGLY].
-
-COMPLETED TASKS:
-When users mention past accomplishments ("I did XXX today"):
-1. add_task() with description
-2. complete_task() with same ID using "x YYYY-MM-DD" format
+- Keep prioritization advice concise - avoid verbose explanations of the matrix itself
+- Prioritize based on dependency chains: complete blocking tasks before dependent ones
+- Consider the "ripple effect" - tasks that unblock multiple other tasks should be prioritized higher
+- Identify critical path tasks that are essential for project completion
+- Suggest parallel work opportunities when dependencies allow
+- Apply the "small wins" principle: suggest completing quick, low-effort tasks early to build momentum
+- Consider task size and energy requirements when suggesting order - match task complexity to available time/energy
+- For task lists, present in logical dependency order with clear "next steps" for each completed task
 
 ERROR HANDLING:
 - Empty results: Suggest next steps
@@ -42,10 +126,35 @@ ERROR HANDLING:
 - Large lists: Use filtering/summaries for 10+ items
 - Failed operations: Explain clearly with alternatives
 
+RESPONSE STYLE:
+- Simple questions (e.g., "how many tasks do I have?") → Brief, direct answers
+- Status requests → Concise summaries without verbose explanations
+- Task lists → ALWAYS show logical dependency sequences, NEVER just due date groupings
+- Complex requests → Provide appropriate detail when needed
+- Avoid verbose explanations for straightforward operations
+- NO "Suggested Next Steps" sections for simple status requests
+- NO verbose explanations when user just wants to see their tasks
+- NEVER organize tasks by "Urgent/Upcoming" or due date categories - show logical flow instead
+
+OUTPUT FORMATTING:
+- Calendar Display: Show calendar output as plain text without backticks, code blocks, or markdown formatting
+- Task Lists: Present tasks in conversational language, not raw todo.txt format
+- Natural Language: Use conversational responses that feel natural and helpful
+- No Technical Details: Avoid mentioning tools, API calls, or technical implementation details
+- Conciseness: For simple questions, provide direct answers without unnecessary explanations
+- Brevity: When listing tasks or providing status updates, be concise and avoid verbose explanations. Prefer unordered lists.
+
 CRITICAL RULES:
-- **Anti-hallucination**: If no tool data exists, say "I need to check your tasks first"
+- Anti-hallucination: If no tool data exists, say "I need to check your tasks first"
 - Use appropriate discovery tools extensively
 - Never assume task existence without verification
 - Maintain todo.txt standard compliance
+- Format Compliance: Always use single + for projects and single @ for contexts (never ++ or @@)
+- Display Formatting: When showing calendar output, display it as plain text without backticks or code blocks
+- Proactive Task Creation: When users request to add a task, create it immediately with inferred tags and due dates unless genuinely ambiguous
+- No Unnecessary Confirmation: Don't ask for confirmation when the task intent is clear and appropriate tags/due dates can be inferred
+- Due Date Intelligence: Always infer reasonable due dates using task nature, calendar context, existing patterns, and common sense. Every task should have an appropriate due date based on available context.
+- Response Length: Match response length to question complexity - simple questions deserve simple answers
+- Format Consistency: Maintain uniform spacing, indentation, and structure across all responses. When listing items, use consistent numbering patterns and visual elements throughout the entire list
 
 AVAILABLE TOOLS: {tools_section}

todo_agent/interface/cli.py

@@ -78,8 +78,8 @@ class CLI:
         self.inference = Inference(self.config, self.tool_handler, self.logger)
         self.logger.debug("Inference engine initialized")
 
-        # Initialize rich console for animations with consistent width
-        self.console = Console(width=CLI_WIDTH)
+        # Initialize rich console for animations with consistent width and color support
+        self.console = Console(width=CLI_WIDTH, color_system="auto")
 
         self.logger.info("CLI initialization completed")
 
@@ -136,21 +136,21 @@ class CLI:
         """Get session memory usage as a progress bar."""
         # Get conversation manager to access memory limits and current usage
         conversation_manager = self.inference.get_conversation_manager()
-        
+
         # Get current usage from conversation summary
         summary = conversation_manager.get_conversation_summary()
         current_tokens = summary.get("estimated_tokens", 0)
         current_messages = summary.get("total_messages", 0)
-        
+
         # Get limits from conversation manager
         max_tokens = conversation_manager.max_tokens
         max_messages = conversation_manager.max_messages
-        
+
         # Create memory usage bar
         memory_bar = PanelFormatter.create_memory_usage_bar(
             current_tokens, max_tokens, current_messages, max_messages
         )
-        
+
         return memory_bar
 
     def run(self) -> None:
@@ -165,8 +165,9 @@ class CLI:
 
         while True:
             try:
-                # Print prompt with unicode character
-                user_input = self.console.input("\n[bold cyan]▶[/bold cyan] ").strip()
+                # Print prompt character on separate line to prevent deletion
+                self.console.print("\n[bold cyan]▶[/bold cyan]", end="\n")
+                user_input = self.console.input().strip()
 
                 if user_input.lower() in ["quit", "exit", "q"]:
                     self.logger.info("User requested exit")
@@ -208,7 +209,9 @@ class CLI:
                     try:
                         output = self.todo_shell.list_tasks()
                         formatted_output = TaskFormatter.format_task_list(output)
-                        task_panel = PanelFormatter.create_task_panel(formatted_output)
+                        task_panel = PanelFormatter.create_task_panel(
+                            formatted_output
+                        )
                         self.console.print(task_panel)
                     except Exception as e:
                         self.logger.error(f"Error listing tasks: {e!s}")
@@ -218,6 +221,23 @@ class CLI:
                         self.console.print(error_msg)
                     continue
 
+                if user_input.lower() == "done":
+                    self.logger.debug("User requested completed task list")
+                    try:
+                        output = self.todo_shell.list_completed()
+                        formatted_output = TaskFormatter.format_completed_tasks(output)
+                        task_panel = PanelFormatter.create_task_panel(
+                            formatted_output, title="✅ Completed Tasks"
+                        )
+                        self.console.print(task_panel)
+                    except Exception as e:
+                        self.logger.error(f"Error listing completed tasks: {e!s}")
+                        error_msg = ResponseFormatter.format_error(
+                            f"Failed to list completed tasks: {e!s}"
+                        )
+                        self.console.print(error_msg)
+                    continue
+
                 self.logger.info(
                     f"Processing user request: {user_input[:50]}{'...' if len(user_input) > 50 else ''}"
                 )
@@ -225,10 +245,10 @@ class CLI:
 
                 # Format the response and create a panel
                 formatted_response = ResponseFormatter.format_response(response)
-                
+
                 # Get memory usage
                 memory_usage = self._get_memory_usage()
-                
+
                 # Create response panel with memory usage
                 response_panel = PanelFormatter.create_response_panel(
                     formatted_response, memory_usage=memory_usage

todo_agent/interface/formatters.py

@@ -7,7 +7,6 @@ from typing import Any, Dict, Optional
 from rich.align import Align
 from rich.box import ROUNDED
 from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
 from rich.table import Table
 from rich.text import Text
 
@@ -22,14 +21,13 @@ class TaskFormatter:
     @staticmethod
     def format_task_list(raw_tasks: str) -> Text:
         """
-        Format a raw task list with unicode characters and numbering.
+        Format a raw task list while preserving ANSI color codes from todo.sh.
 
         Args:
-            raw_tasks: Raw task output from todo.sh
-            title: Title for the task list
+            raw_tasks: Raw task output from todo.sh with ANSI codes
 
         Returns:
-            Formatted task list as Rich Text object
+            Formatted task list as Rich Text object with preserved ANSI codes
         """
         if not raw_tasks.strip():
             return Text("No tasks found.")
@@ -38,19 +36,15 @@ class TaskFormatter:
         formatted_text = Text()
         task_count = 0
 
-        # Add header
-        formatted_text.append("Tasks", style="bold blue")
-        formatted_text.append("\n\n")
+
 
         for line in lines:
             line = line.strip()
             # Skip empty lines, separators, and todo.sh's own summary line
             if line and line != "--" and not line.startswith("TODO:"):
                 task_count += 1
-                # Parse todo.txt format and make it more readable
-                formatted_task = TaskFormatter._format_single_task(line, task_count)
-                # Create a Text object that respects ANSI codes
-                task_text = Text.from_ansi(formatted_task)
+                # Preserve the original ANSI codes by using Text.from_ansi directly
+                task_text = Text.from_ansi(line)
                 formatted_text.append(task_text)
                 formatted_text.append("\n")
 
@@ -63,6 +57,48 @@ class TaskFormatter:
 
         return formatted_text
 
+
+
+    @staticmethod
+    def format_completed_tasks(raw_tasks: str) -> Text:
+        """
+        Format a raw completed task list while preserving ANSI color codes from todo.sh.
+
+        Args:
+            raw_tasks: Raw completed task output from todo.sh with ANSI codes
+
+        Returns:
+            Formatted completed task list as Rich Text object with preserved ANSI codes
+        """
+        if not raw_tasks.strip():
+            return Text("No completed tasks found.")
+
+        lines = raw_tasks.strip().split("\n")
+        formatted_text = Text()
+        task_count = 0
+
+
+
+        for line in lines:
+            line = line.strip()
+            # Skip empty lines, separators, and todo.sh's own summary line
+            if line and line != "--" and not line.startswith("TODO:"):
+                task_count += 1
+                # Preserve the original ANSI codes by using Text.from_ansi directly
+                task_text = Text.from_ansi(line)
+                formatted_text.append(task_text)
+                formatted_text.append("\n")
+
+        # Add task count at the end
+        if task_count > 0:
+            formatted_text.append("\n")
+        else:
+            formatted_text = Text("No completed tasks found.")
+
+        return formatted_text
+
+
+
     @staticmethod
     def _format_single_task(task_line: str, task_number: int) -> str:
         """
@@ -101,6 +137,33 @@ class TaskFormatter:
 
         return formatted_line
 
+    @staticmethod
+    def _format_single_completed_task(task_line: str, task_number: int) -> str:
+        """
+        Format a single completed task line with unicode characters.
+
+        Args:
+            task_line: Raw completed task line from todo.sh
+            task_number: Task number for display
+
+        Returns:
+            Formatted completed task string
+        """
+        # Parse completed task format: "x 2025-08-29 2025-08-28 Clean cat box @home +chores"
+        # The format is: "x completion_date creation_date description"
+        parts = task_line.split(
+            " ", 2
+        )  # Split on first two spaces to separate x, dates, and description
+        if len(parts) < 3:
+            return f"  {task_number:2d} │   │ {task_line}"
+
+        description = parts[2]
+
+        # Format with unicode characters
+        formatted_line = f"  {task_number:2d} │ {description}"
+
+        return formatted_line
+
     @staticmethod
     def format_projects(raw_projects: str) -> str:
         """
@@ -279,6 +342,7 @@ class TableFormatter:
             ("help", "Show this help message"),
             ("about", "Show application information"),
             ("list", "List all tasks (no LLM interaction)"),
+            ("done", "List completed tasks (no LLM interaction)"),
             ("quit", "Exit the application"),
         ]
 
@@ -340,28 +404,32 @@ class PanelFormatter:
         )
 
     @staticmethod
-    def create_task_panel(content: str, title: str = "📋 Current Tasks") -> Panel:
+    def create_task_panel(content: str | Text, title: str = "📋 Current Tasks") -> Panel:
         """Create a panel for displaying task lists."""
         return Panel(
             content, title=title, border_style="dim", box=ROUNDED, width=PANEL_WIDTH
         )
 
     @staticmethod
-    def create_response_panel(content: str, title: str = "🤖 Assistant", memory_usage: Optional[Text] = None) -> Panel:
+    def create_response_panel(
+        content: str, title: str = "🤖 Assistant", memory_usage: Optional[Text] = None
+    ) -> Panel:
         """Create a panel for displaying LLM responses."""
         if memory_usage:
             # Create the combined content with centered memory usage
+            combined_content = Text()
+            combined_content.append(content)
+            combined_content.append("\n\n")
+            combined_content.append("─" * (PANEL_WIDTH - 4))  # Separator line
+            combined_content.append("\n")
+            combined_content.append(memory_usage)
+
             return Panel(
-                Align.center(
-                    Text.assemble(
-                        content,
-                        "\n\n",
-                        "─" * (PANEL_WIDTH - 4),  # Separator line
-                        "\n",
-                        memory_usage
-                    )
-                ),
-                title=title, border_style="dim", box=ROUNDED, width=PANEL_WIDTH
+                Align.center(combined_content),
+                title=title,
+                border_style="dim",
+                box=ROUNDED,
+                width=PANEL_WIDTH,
             )
         else:
             return Panel(
@@ -415,43 +483,71 @@ class PanelFormatter:
         )
 
     @staticmethod
-    def create_memory_usage_bar(current_tokens: int, max_tokens: int, current_messages: int, max_messages: int) -> Text:
+    def create_memory_usage_bar(
+        current_tokens: int, max_tokens: int, current_messages: int, max_messages: int
+    ) -> Text:
         """
         Create a rich progress bar showing session memory usage.
-        
+
         Args:
             current_tokens: Current number of tokens in conversation
             max_tokens: Maximum allowed tokens
             current_messages: Current number of messages in conversation
             max_messages: Maximum allowed messages
-            
+
         Returns:
             Rich Text object with memory usage progress bar
         """
         # Calculate percentage
         token_percentage = min(100, (current_tokens / max_tokens) * 100)
-        
-        # Determine color based on usage
-        if token_percentage >= 90:
-            color = "red"
-        elif token_percentage >= 75:
-            color = "yellow"
-        else:
-            color = "green"
-        
-        # Create the progress bar text
+
+        # Create the progress bar text with new layout
         memory_text = Text()
-        memory_text.append(f"{current_tokens:,}/{max_tokens:,} ", style="dim")
-        
-        # Create a simple text-based progress bar
-        bar_length = 25
+
+        # Calculate available width (PANEL_WIDTH - 4 for borders = 94 chars)
+        # Account for emoji width by using a slightly reduced width
+        available_width = 92  # Balance between full width and emoji spacing
+
+        # Left section: Floppy disk + token count
+        left_section = f"💾 {current_tokens:,}/{max_tokens:,}"
+        left_width = len(left_section)
+
+        # Right section: Message count + floppy disk
+        right_section = f"{current_messages}/{max_messages} 💾"
+        right_width = len(right_section)
+
+        # Center section: Progress bar (2x wider = 50 chars) + percentage
+        bar_length = 50
         token_filled = int((token_percentage / 100) * bar_length)
         token_bar = "█" * token_filled + "░" * (bar_length - token_filled)
-        memory_text.append(f"[{token_bar}] ", style="dim")
-        memory_text.append(f"{token_percentage:.1f}%", style="dim")
-        
-        # Add message count without progress bar
-        memory_text.append(" | ", style="dim")
-        memory_text.append(f"{current_messages}/{max_messages}", style="dim")
-        
+        center_section = f"[{token_bar}] {token_percentage:.1f}%"
+        center_width = len(center_section)
+
+        # Calculate spacing to center the progress bar
+        total_content_width = left_width + center_width + right_width
+        remaining_space = available_width - total_content_width
+
+        # Ensure we have enough space, if not, reduce the progress bar length
+        if remaining_space < 0:
+            # Reduce bar length to fit everything
+            excess = abs(remaining_space)
+            bar_length = max(30, 50 - excess)  # Minimum 30 chars
+            token_filled = int((token_percentage / 100) * bar_length)
+            token_bar = "█" * token_filled + "░" * (bar_length - token_filled)
+            center_section = f"[{token_bar}] {token_percentage:.1f}%"
+            center_width = len(center_section)
+            total_content_width = left_width + center_width + right_width
+            remaining_space = available_width - total_content_width
+
+        # Distribute remaining space equally for symmetrical layout
+        left_spacing = remaining_space // 2
+        right_spacing = remaining_space - left_spacing
+
+        # Build the final layout
+        memory_text.append(left_section, style="dim")
+        memory_text.append(" " * left_spacing)
+        memory_text.append(center_section, style="dim")
+        memory_text.append(" " * right_spacing)
+        memory_text.append(right_section, style="dim")
+
         return memory_text

todo_agent/interface/tools.py

@@ -2,6 +2,7 @@
 Tool definitions and schemas for LLM function calling.
 """
 
+import subprocess
 from typing import Any, Callable, Dict, List, Optional
 
 try:
@@ -62,8 +63,12 @@ class ToolCallHandler:
                         "1) User wants to see their tasks, "
                         "2) You need to find a specific task by description, "
                         "3) You need to check for potential duplicates before adding new tasks, "
-                        "4) You need to understand the current state before making changes. "
+                        "4) You need to understand the current state before making changes, "
+                        "5) User says they finished/completed a task and you need to find the matching task. "
                         "CRITICAL: ALWAYS use this before add_task() to check for similar existing tasks. "
+                        "CRITICAL: ALWAYS use this when user mentions task completion to find the correct task number. "
+                        "COMPLETION INTELLIGENCE: When searching for completion matches, if exactly one task clearly "
+                        "matches the user's description, proceed to complete it immediately without asking for confirmation. "
                         "IMPORTANT: When presenting the results to the user, convert the raw todo.txt format "
                         "into conversational language. Do not show the raw format like '(A) task +project @context'. "
                         "STRATEGIC CONTEXT: This is the primary discovery tool - call this FIRST when you need to "
@@ -76,7 +81,7 @@ class ToolCallHandler:
                                 "type": "string",
                                 "description": (
                                     "Optional filter string (e.g., '+work', '@office', '(A)') - "
-                                    "use when you want to see only specific tasks"
+                                    "use when you want to see only specific tasks or when searching for completion matches"
                                 ),
                             }
                         },
@@ -166,7 +171,10 @@ class ToolCallHandler:
                         "use list_tasks() and list_completed_tasks() to check for potential duplicates. Look for tasks with "
                         "similar descriptions, keywords, or intent. If you find similar tasks, "
                         "ask the user if they want to add a new task or modify an existing one. "
-                        "If project or context is ambiguous, use discovery tools first. "
+                        "AUTOMATIC INFERENCE: When project, context, or due date is not specified, automatically infer appropriate tags "
+                        "and due dates based on the task content, natural language expressions, task nature, calendar context, and existing patterns. "
+                        "DUE DATE INFERENCE: Extract temporal expressions and use common sense to infer appropriate due dates based on task type, "
+                        "work patterns, personal schedules, and existing task due date patterns. Only ask for clarification when genuinely ambiguous. "
                         "Always provide a complete, natural response to the user. "
                         "STRATEGIC CONTEXT: This is a modification tool - call this LAST after using "
                         "discovery tools (list_tasks, list_projects, list_contexts list_completed_tasks) "
@@ -193,7 +201,7 @@ class ToolCallHandler:
                             },
                             "due": {
                                 "type": "string",
-                                "description": "Optional due date in YYYY-MM-DD format",
+                                "description": "Optional due date in YYYY-MM-DD format. Automatically inferred from natural language expressions like 'tomorrow', 'next week', 'by Friday', 'urgent', 'asap'",
                             },
                         },
                         "required": ["description"],
@@ -206,11 +214,13 @@ class ToolCallHandler:
                     "name": "complete_task",
                     "description": (
                         "Mark a specific task as complete by its line number. IMPORTANT: "
-                        "Before completing, use list_completed_tasks() to check if it's already done. "
-                        "If multiple tasks match the description, ask the user to clarify which one. "
+                        "When user says they finished/completed a task, FIRST use list_tasks() to find matching tasks, "
+                        "then list_completed_tasks() to verify it's not already done. "
+                        "COMPLETION LOGIC: If user's statement clearly matches exactly one task, complete it immediately. "
+                        "If multiple tasks match, show numbered options and ask for clarification. "
+                        "If the match is ambiguous, ask for confirmation. "
                         "STRATEGIC CONTEXT: This is a modification tool - call this LAST after using "
-                        "discovery tools (list_tasks, list_completed_tasks) "
-                        "to verify the task exists and hasn't already been completed."
+                        "discovery tools (list_tasks, list_completed_tasks) to verify the task exists and status."
                     ),
                     "parameters": {
                         "type": "object",
@@ -434,8 +444,69 @@ class ToolCallHandler:
                     "parameters": {"type": "object", "properties": {}, "required": []},
                 },
             },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_calendar",
+                    "description": (
+                        "Get a calendar for a specific month and year using the system 'cal' command. "
+                        "Use this when: "
+                        "1) User asks to see a calendar for a specific month/year, "
+                        "2) User wants to plan tasks around specific dates, "
+                        "3) User needs to see what day of the week a date falls on, "
+                        "4) User wants to visualize the current month or upcoming months. "
+                        "The calendar will show the month in a traditional calendar format with days of the week. "
+                        "IMPORTANT: When displaying the calendar output, present it directly without wrapping in backticks or code blocks. "
+                        "The calendar should be displayed as plain text in the conversation."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "month": {
+                                "type": "integer",
+                                "description": "Month number (1-12, where 1=January, 12=December)",
+                                "minimum": 1,
+                                "maximum": 12,
+                            },
+                            "year": {
+                                "type": "integer",
+                                "description": "Year (4-digit format, e.g., 2025)",
+                                "minimum": 1900,
+                                "maximum": 2100,
+                            },
+                        },
+                        "required": ["month", "year"],
+                    },
+                },
+            },
         ]
 
+    def _get_calendar(self, month: int, year: int) -> str:
+        """
+        Get a calendar for the specified month and year using the system 'cal' command.
+
+        Args:
+            month: Month number (1-12)
+            year: Year (4-digit format)
+
+        Returns:
+            Calendar output as a string
+        """
+        try:
+            # Use the cal command with specific month and year
+            result = subprocess.run(
+                ["cal", str(month), str(year)],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.stdout.strip()
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # Fallback to Python calendar module
+            import calendar
+
+            return calendar.month(year, month).strip()
+
     def _format_tool_signature(self, tool_name: str, arguments: Dict[str, Any]) -> str:
         """Format tool signature with parameters for logging."""
         if not arguments:
@@ -503,6 +574,7 @@ class ToolCallHandler:
             "move_task": self.todo_manager.move_task,
             "archive_tasks": self.todo_manager.archive_tasks,
             "deduplicate_tasks": self.todo_manager.deduplicate_tasks,
+            "get_calendar": self._get_calendar,
         }
 
         if tool_name not in method_map:

{todo_agent-0.2.4.dist-info → todo_agent-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.2.4
+Version: 0.2.6
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate

todo_agent-0.2.6.dist-info/RECORD

@@ -0,0 +1,29 @@
+todo_agent/__init__.py,sha256=RUowhd14r3tqB_7rl83unGV8oBjra3UOIl7jix-33fk,254
+todo_agent/_version.py,sha256=2Q6v117QPuRsVsIEaHT3nJJVx7xxa47FYOkmuhVbGAI,704
+todo_agent/main.py,sha256=-ryhMm4c4sz4e4anXI8B-CYnpEh5HIkmnYcnGxcWHDk,1628
+todo_agent/core/__init__.py,sha256=QAZ4it63pXv5-DxtNcuSAmg7ZnCY5ackI5yycvKHr9I,365
+todo_agent/core/conversation_manager.py,sha256=gSCcX356UJ0T3FCTS1q0fOud0ytFKXptf9RyKjzpTYI,11640
+todo_agent/core/exceptions.py,sha256=cPvvkIbKdI7l51wC7cE-ZxUi54P3nf2m7x2lMNMRFYM,399
+todo_agent/core/todo_manager.py,sha256=Dyc5NbDd_u21nJlS-C8KxefGJpEcHOLtL21qqQEit2Q,9142
+todo_agent/infrastructure/__init__.py,sha256=SGbHXgzq6U1DMgOfWPMsWEK99zjPSF-6gzy7xqc5fsI,284
+todo_agent/infrastructure/calendar_utils.py,sha256=HmF0ykXF_6GbdoJvZLIv6fKwT6ipixoywdTMkIXmkGU,1871
+todo_agent/infrastructure/config.py,sha256=zyp6qOlg1nN_awphivlgGNBE6fL0Hf66YgvWxR8ldyQ,2117
+todo_agent/infrastructure/inference.py,sha256=J6i9jtzOVo2Yy3e6yAUBH22ik3OqHs1I0zrADhs4IRk,10676
+todo_agent/infrastructure/llm_client.py,sha256=ZoObyqaRP6i_eqGYGfJWGeWTJ-VNxpY70ay04vt2v_E,1390
+todo_agent/infrastructure/llm_client_factory.py,sha256=-tktnVOIF7B45WR7AuLoi7MKnEyuM8lgg1jjc4T1FhM,1929
+todo_agent/infrastructure/logger.py,sha256=2ykG_0lyzmEGxDF6ZRl1qiTUGDuFeQgzv4Na6vRmXcM,4110
+todo_agent/infrastructure/ollama_client.py,sha256=zElS9OhkieCJQFSUxBqBd6k-u9I0cIpMwJG08dLQ1QA,5926
+todo_agent/infrastructure/openrouter_client.py,sha256=u-yIENA6PVpBKS0oy6l-muzZDvCtJIP9lF8AjeHgvtQ,7153
+todo_agent/infrastructure/todo_shell.py,sha256=z6kqUKDX-i4DfYJKoOLiPLCp8y6m1HdTDLHTvmLpzMc,5801
+todo_agent/infrastructure/token_counter.py,sha256=PCKheOVJbp1s89yhh_i6iKgURMt9mVoYkwjQJCc2xCE,4958
+todo_agent/infrastructure/prompts/system_prompt.txt,sha256=Y2bb9gcdpJeybaaBdBZhI0FmmQ5jJQwnz0BdSRGLJCw,10726
+todo_agent/interface/__init__.py,sha256=vDD3rQu4qDkpvVwGVtkDzE1M4IiSHYzTif4GbYSFWaI,457
+todo_agent/interface/cli.py,sha256=1nPUFEzbSl4bdy6hcIGM1izGWDwbjaijfBCWfPBb31E,12062
+todo_agent/interface/formatters.py,sha256=Oc7ynL7vpb4i8f-XQM38gJlqTOVZfzyTBwWceeMHV_Y,18912
+todo_agent/interface/tools.py,sha256=RkxsyqYbp0QYwtnJMXixBf727Atcp8DY6dm6949DTMY,32739
+todo_agent-0.2.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+todo_agent-0.2.6.dist-info/METADATA,sha256=t7jXtBUZ9_blq8-9505gmvQrxIvTZ27EPLwQGPfi_dE,10047
+todo_agent-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+todo_agent-0.2.6.dist-info/entry_points.txt,sha256=4W7LrCib6AXP5IZDwWRht8S5gutLu5oNfTJHGbt4oHs,52
+todo_agent-0.2.6.dist-info/top_level.txt,sha256=a65mlPIhPZHuq2bRIi_sCMAIJsUddvXt171OBF6r6co,11
+todo_agent-0.2.6.dist-info/RECORD,,

todo_agent-0.2.4.dist-info/RECORD

@@ -1,28 +0,0 @@
-todo_agent/__init__.py,sha256=RUowhd14r3tqB_7rl83unGV8oBjra3UOIl7jix-33fk,254
-todo_agent/_version.py,sha256=NRw4Jle4n9v_DD2wtplRqflGCvX8OU5eAjycYY0vY3Y,704
-todo_agent/main.py,sha256=-ryhMm4c4sz4e4anXI8B-CYnpEh5HIkmnYcnGxcWHDk,1628
-todo_agent/core/__init__.py,sha256=QAZ4it63pXv5-DxtNcuSAmg7ZnCY5ackI5yycvKHr9I,365
-todo_agent/core/conversation_manager.py,sha256=gSCcX356UJ0T3FCTS1q0fOud0ytFKXptf9RyKjzpTYI,11640
-todo_agent/core/exceptions.py,sha256=cPvvkIbKdI7l51wC7cE-ZxUi54P3nf2m7x2lMNMRFYM,399
-todo_agent/core/todo_manager.py,sha256=wV-J_E_aK7yRNT-WbILKJgqBFhbcXDZa6Pb4IjbgGkU,7974
-todo_agent/infrastructure/__init__.py,sha256=SGbHXgzq6U1DMgOfWPMsWEK99zjPSF-6gzy7xqc5fsI,284
-todo_agent/infrastructure/config.py,sha256=zyp6qOlg1nN_awphivlgGNBE6fL0Hf66YgvWxR8ldyQ,2117
-todo_agent/infrastructure/inference.py,sha256=XCM18hpHwWxDLV-31yO_UOYbqQ7lRjGz-PQduyp6Xio,10289
-todo_agent/infrastructure/llm_client.py,sha256=ZoObyqaRP6i_eqGYGfJWGeWTJ-VNxpY70ay04vt2v_E,1390
-todo_agent/infrastructure/llm_client_factory.py,sha256=SmPHNS4QifFI8CmsAz7uTcYjTdFzq8x9jVNybOmyerk,1884
-todo_agent/infrastructure/logger.py,sha256=2ykG_0lyzmEGxDF6ZRl1qiTUGDuFeQgzv4Na6vRmXcM,4110
-todo_agent/infrastructure/ollama_client.py,sha256=6WsjSftsHNt-CeScK6GSrJ_CMe80OiATT3idcJgPCBk,5654
-todo_agent/infrastructure/openrouter_client.py,sha256=GVOJTzPDOKNdHEu-y-HQygMcLvrFw1KB6NZU_rJR3-c,6859
-todo_agent/infrastructure/todo_shell.py,sha256=z6kqUKDX-i4DfYJKoOLiPLCp8y6m1HdTDLHTvmLpzMc,5801
-todo_agent/infrastructure/token_counter.py,sha256=PCKheOVJbp1s89yhh_i6iKgURMt9mVoYkwjQJCc2xCE,4958
-todo_agent/infrastructure/prompts/system_prompt.txt,sha256=uCb6yz3uDQdwcB8HJcF0y1_1b75oRtRnCMMHQLHI3NI,2415
-todo_agent/interface/__init__.py,sha256=vDD3rQu4qDkpvVwGVtkDzE1M4IiSHYzTif4GbYSFWaI,457
-todo_agent/interface/cli.py,sha256=FacwTDjLP60qAQ_BsM_7_jM9liYJpZpRdXpBNwNuO2Y,11060
-todo_agent/interface/formatters.py,sha256=QT6IgBVX6ghL8UWH54KFtJY9n9GbrPvOizjCN8emMGg,15503
-todo_agent/interface/tools.py,sha256=mlPPLVwECYrTtOX8ysIORRfErIOJl43qlTvfdpy2Vbs,28559
-todo_agent-0.2.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-todo_agent-0.2.4.dist-info/METADATA,sha256=fYnY58TYzNuQtiu2WBr3fRJwJEIh6bbt4gA2lrNC_9A,10047
-todo_agent-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-todo_agent-0.2.4.dist-info/entry_points.txt,sha256=4W7LrCib6AXP5IZDwWRht8S5gutLu5oNfTJHGbt4oHs,52
-todo_agent-0.2.4.dist-info/top_level.txt,sha256=a65mlPIhPZHuq2bRIi_sCMAIJsUddvXt171OBF6r6co,11
-todo_agent-0.2.4.dist-info/RECORD,,