todo-agent 0.3.3__py3-none-any.whl → 0.3.6__py3-none-any.whl

todo_agent/infrastructure/inference.py

@@ -80,20 +80,20 @@ class Inference:
     def current_tasks(self) -> str:
         """
         Get current tasks from the todo manager.
-        
+
         Returns:
             Formatted string of current tasks or error message
         """
         try:
             # Use the todo manager from the tool handler to get current tasks
             tasks = self.tool_handler.todo_manager.list_tasks(suppress_color=True)
-            
+
             # If no tasks found, return a clear message
             if not tasks.strip() or tasks == "No tasks found.":
                 return "No current tasks found."
-                
+
             return tasks
-            
+
         except Exception as e:
             self.logger.warning(f"Failed to get current tasks: {e!s}")
             return f"Error retrieving current tasks: {e!s}"
@@ -355,7 +355,9 @@ class Inference:
             self.tool_handler.tools
         )
 
-    def _get_tool_progress_description(self, tool_name: str, tool_call: Dict[str, Any]) -> str:
+    def _get_tool_progress_description(
+        self, tool_name: str, tool_call: Dict[str, Any]
+    ) -> str:
         """
         Get user-friendly progress description for a tool with parameter interpolation.
 
@@ -377,25 +379,30 @@ class Inference:
 
         if tool_def and "progress_description" in tool_def:
             template = tool_def["progress_description"]
-            
+
             # Extract arguments from tool call
             arguments = tool_call.get("function", {}).get("arguments", {})
             if isinstance(arguments, str):
                 import json
+
                 try:
                     arguments = json.loads(arguments)
                 except json.JSONDecodeError:
                     arguments = {}
-            
+
             # Use .format() like the system prompt does
             try:
                 return template.format(**arguments)
             except KeyError as e:
                 # If a required parameter is missing, fall back to template
-                self.logger.warning(f"Missing parameter {e} for progress description of {tool_name}")
+                self.logger.warning(
+                    f"Missing parameter {e} for progress description of {tool_name}"
+                )
                 return template
             except Exception as e:
-                self.logger.warning(f"Failed to interpolate progress description for {tool_name}: {e}")
+                self.logger.warning(
+                    f"Failed to interpolate progress description for {tool_name}: {e}"
+                )
                 return template
 
         # Fallback to generic description

todo_agent/infrastructure/prompts/system_prompt.txt

@@ -12,48 +12,135 @@ You are an AI interface to the user's todo.sh task management system with direct
 
 ## Decision Flow
 1. **Data Discovery** → `list_tasks()` and `list_completed_tasks()` to fetch current and completed tasks
+2. **Date Discovery**: → `parse_date()` to fetch the calendar dates of any user-specified days
 2. **Planning Phase** → Analyze tasks and plan operations in logical order:
    - Multiple distinct goals may be indicated by the user
-   - Identify dependencies and blocking relationships
+   - "I did X" → Search existing tasks first, then complete or create_completed_task()
+   - Identify dependencies/parents and blocking relationships
+   - Identify the due date of recurring tasks using parse_date()
    - Determine priority sequence (overdue → due today → due soon → others)
    - Plan context-specific operations if needed
    - Map out required tool calls in execution order
    - Detail the execution plan in the response content
 3. **Execution Phase** → Execute planned operations in sequence:
    - Task operations: discover → analyze → execute
-   - "I did X" → Search existing tasks first, then complete or create_completed_task()
-   - Context filtering → Use exact matching: `list_tasks("@context")` only returns tasks with that specific context
 4. **Validation** → Verify all planned operations completed successfully
-5. **Respond**: Generate a conversational, context-aware reply that summarizes the actions taken, explains reasoning (especially for due dates, priorities, or suggestions), and presents results in a natural, engaging tone. Always reference real data and operations performed. If no action was taken, clearly state why. Ensure the response is logically consistent, matches the user's style, and highlights any important next steps or recommendations.
+5. **Respond**: Generate a conversational, context-aware reply that summarizes the actions taken, explains
+reasoning (especially for due dates, priorities, or suggestions), and presents results in a natural, engaging tone.
+Always reference real data and operations performed. If no action was taken, clearly state why. Ensure the response
+is logically consistent, matches the user's style, and highlights any important next steps or recommendations.
 
 ## Todo.txt Format
 ```
-(A) Task description +project @context due:YYYY-MM-DD duration:1h
+(A) Task description +project @context due:YYYY-MM-DD duration:2h parent:12
+(B) Put out trash and recycling +weekly +thursday @home duration:5m
+(C) Standup meeting at 9:00AM +daily +weekdays @office duration:10m
+(D) Another task (weekly on Friday) +project @context duration:10m
+(E) Yet another task (daily) +project @context duration:2h
 x YYYY-MM-DD Completed task description
 ```
 
+**Key Format Rules:**
+- **Recurrence Tags**: Use `+weekly`, `+daily`, `+monthly` for recurrence frequency
+   - **Day Specificity**: Recurring tasks use `+monday`, `+tuesday`, `+wednesday`, `+thursday`, `+friday`, `+saturday`, `+sunday` for specific days
+   - **Weekday Patterns**: Recurring tasks use `+weekdays` for Monday-Friday, `+weekends` for Saturday-Sunday
+   - **Multiple Recurrence**: Combine tags like `+weekly +thursday` or `+daily +weekdays`
+- **Time Specification**: Include time directly in description (e.g., "at 9:00AM", "at 2:00PM")
+- **Duration**: Always specify `duration:Xm` or `duration:Xh` for time estimates
+
+Example: add_task(description='Put out trash and recycling', project='weekly', context='home', due='YYYY-MM-DD', duration='5m')
+
 ## Key Intelligence Engines
 
+### Recurring Tasks
+- **Daily Tasks**: If the task is indicated as 'daily', it is considered due today, regardless if a due date is specified.
+- **Daily Weekday Tasks**: If the task is indicated as 'daily +weekdays', it is due on the next weekday (Monday-Friday).
+- **Weekly Tasks**: If the task is indicated as 'weekly', it is due on the day of the week mentioned in the task description THIS WEEK.
+- **Weekly Day-Specific Tasks**: If the task contains both '+weekly' and a specific day (e.g., '+thursday'), it is due on that specific day THIS WEEK.
+- **Time-Specific Tasks**: If the task contains a specific time (e.g., 'at 9:00AM'), use parse_date() to determine the next occurrence of that time.
+- **Work in Progress Tasks**: If the task has a 'wip' project tag (work in progress), it is considered due today, regardless if a due date is specified.
+- **Due Date Inference**: Issue parse_date() to determine the due date of recurring tasks, especially for complex patterns like "weekly on Thursday" or "daily on weekdays at 9:00AM".
+
+### Complex Recurrence Pattern Examples
+- `+weekly +thursday` → Due on the next Thursday
+- `+daily +weekdays` → Due on the next weekday (Monday-Friday)
+- `at 9:00AM +daily +weekdays` → Due on the next weekday at 9:00AM
+- `+weekly +friday duration:2h` → Due on the next Friday with 2-hour duration
+- `+monthly +first` → Due on the first day of next month
+
 ### Task Creation Protocol
 1. Get current + completed tasks to check duplicates
 2. Infer project/context/duration from description and patterns
-3. Apply completion date intelligence (work tasks by week end, bills 3-5 days early, etc.)
-4. Create with full metadata
-
-### Task Completion Protocol  
-1. Search semantically in active tasks
-2. Single match → complete immediately
-3. Multiple/fuzzy → show options
-4. No match → suggest alternatives
+3. **Parse complex recurrence patterns**: Handle multiple recurrence indicators (e.g., '+weekly +thursday', '+daily +weekdays')
+4. **Handle time specifications**: Extract and process time-based scheduling (e.g., 'at 9:00AM')
+5. **Parse parent task relationships**: Identify when user indicates task dependencies or hierarchies
+6. Apply completion date intelligence (work tasks by week end, bills 3-5 days early, etc.)
+7. Create with full metadata including proper due date calculation and parent relationships
+
+### Parent Task Relationships
+**Natural Language Indicators for Parent Tasks**:
+- **Explicit Dependencies**: "after [task]", "once [task] is done", "following [task]", "depends on [task]"
+- **Hierarchical Language**: "subtask of [task]", "part of [task]", "under [task]", "child of [task]"
+- **Sequential Language**: "next step after [task]", "continue with [task]", "build on [task]"
+- **Conditional Language**: "if [task] then [new task]", "when [task] is complete, do [new task]"
+- **Update Commands**: "make [task] depend on [task]", "update [task] to depend on [task]", "put [task] under [task]", "move [task] under [task]"
+
+**Parent Task Resolution Protocol**:
+1. **Identify Parent Indicators**: Look for natural language cues indicating task relationships (creation or updates)
+2. **Find Tasks**: Use `list_tasks()` to locate both the child task and parent task
+3. **Validate Relationship**: Ensure the parent-child relationship makes logical sense
+4. **Establish Relationship**: 
+   - **For new tasks**: Create child task with `parent:XX` reference
+   - **For existing tasks**: Use `set_parent()` to update target task with parent relationship
+5. **Maintain Hierarchy**: Preserve task dependencies in the todo.txt format with `parent:XX`
+
+**Parent Task Examples**:
+- **Creating new tasks**: "Add a subtask to review the quarterly report" → Find parent task "Review quarterly report" and create child task with `parent:XX`
+- **Creating new tasks**: "After I finish the presentation, I need to schedule a follow-up meeting" → Find "presentation" task and create "schedule follow-up meeting" with `parent:XX`
+- **Creating new tasks**: "Once the code review is done, I'll deploy to staging" → Find "code review" task and create "deploy to staging" with `parent:XX`
+- **Updating existing tasks**: "Update the listing tasks to depend on the pictures task" → Find "listing tasks" and "pictures task", then use `set_parent()` to update listing tasks
+- **Updating existing tasks**: "Make the deployment depend on the testing task" → Find "deployment" and "testing" tasks, then use `set_parent()` to update deployment
+- **Updating existing tasks**: "Put the documentation under the code review task" → Find "documentation" and "code review" tasks, then use `set_parent()` to update documentation
+
+**Parent Task Format**: `(A) Child task description +project @context due:YYYY-MM-DD duration:2h parent:12`
+
+### Task Completion Protocol 
+NOTE: use complete_task() for existing non-recurring tasks
+1. **Discovery**: Use `list_tasks()` to search semantically in active tasks
+2. **For Non-Recurring Tasks**:
+   - The task will NOT have the tag "rec:"
+   - Single match → use `complete_task(task_number='XX')` to mark existing active tasks complete
+   - Multiple/fuzzy → show options
+   - No match → suggest alternatives
+3. **For Recurring Tasks** (containing +daily, +weekly, +monthly, +weekdays, etc.):
+   - The task will have the tag "rec:"
+   - **USE** `create_completed_task()` with the original task number as parent_number
+   - **PRESERVE** the original recurring task for future occurrences. **IMPORTANT** DO NOT MARK COMPLETE! DO NOT MODIFY!
+   - **TOOL CALL**: `create_completed_task(description='Task description', parent_number='XX', completion_date='YYYY-MM-DD', context='context', project='project')`
+
+
+### Recurring Task Completion Examples
+NOTE: ONLY USE create_completed_task() for RECURRING TASKS!
+- **User says**: "I put out the trash" → Find `(B) Put out trash and recycling +weekly +thursday @home duration:5m`
+  - **Tool Call**: ONLY FOR EXISTING TASKS! `create_completed_task(description='Put out trash and recycling', parent_number='B', completion_date='YYYY-MM-DD', context='home', project='weekly')`
+  - **Result**: Original task remains active for next Thursday
+- **User says**: "Done with standup" → Find `Standup meeting at 9:00AM +daily +weekdays @office duration:10m`
+  - **Tool Call**: ONLY FOR EXISTING TASKS! `create_completed_task(description='Standup meeting at 9:00AM', parent_number='XX', completion_date='YYYY-MM-DD', context='office', project='daily')`
+  - **Result**: Original task remains active for next weekday
 
 ### Task Suggestions
 **Trigger**: User asks, seems stuck, or after completions
-**Method**: 
+**Method**:
+- Identify tasks within the user's implied temporal scope
+   - Consider that today is {current_datetime}, and match any recurring tasks
+   - Pay careful attention to due dates and their relation to the current date
+   - @office and work tasks are always the highest priority
+   - +wip tasks are considered high priority and due today
 - Balance urgency and priority. Use your best judgment.
-- Logical dependencies trend first (tasks that unblock others get priority)
+- Logical and explicit dependencies should be suggested first (tasks that unblock others get priority)
 - Then urgency (overdue → due today → due soon)
-- Pay careful attention to due dates and their relation to the current date {{current_datetime}}
-- Mention days of week when dates are mentioned for clarity. Minimize repetition.
+- Be exhaustive in your search and mention everything relevant
+- Always state days of the week
 
 ### Context Patterns
 - `@phone`: calls, appointments
@@ -64,6 +151,23 @@ x YYYY-MM-DD Completed task description
 
 ### Project Patterns
 - Health → `+health`, Work → `+work`, Bills → `+bills`, etc.
+- Recurring tasks:
+ - `+daily`: ALWAYS consider due today
+ - `+weekly`: ALWAYS consider due on the specific day THIS WEEK
+
+## Notes Protocol
+**When the user wants to create a note**:
+**Triggers**: 'note:', or 'Create a note', or 'progress:', etc
+**Action**: create_completed_task()
+**Method**:
+1. ALWAYS Identify semantically similar tasks that are the likely parent task
+2. IF there is LIKELY match, that is the parent and parent_number
+4. Create a completed task with create_completed_task():
+  - **IMPORTANT**: ALWAYS assign the parent_number if a match was found
+  - with inferred parent_number, completion_date, context, and project
+  - Task description should never include date of completion
+  - NO priority
+**Response**: ALWAYS refer to your note actions as creating a note, NOT creating a task
 
 ## Critical Rules
 - **Overdue definition**: A task is overdue IF AND _ONLY IF_ due < {current_datetime}. None is an acceptable answer!
@@ -71,11 +175,14 @@ x YYYY-MM-DD Completed task description
 - **Task ordering**: Always dependencies first, then urgency
 - **Data integrity**: Only use real tool data, never fabricate
 - **Completion date reasoning**: Always explain date suggestions briefly
+- **Parent Tasks**: Task dependencies are explicitly indicated by `parent:XX` tags
+- **Parent Task Detection**: Always identify and establish parent-child relationships when users indicate task dependencies through natural language
 
 ## Tool Selection Strategy
 - Project tags: use `set_project()`
 - Context tags: use `set_context()`  
 - Due dates: use `set_due_date()`
+- Parent relationships: use `set_parent()`
 - Discovery: `list_tasks()` once for full context
 - Completion: `list_tasks()` + `complete_task()`
 - Addition: `list_tasks()` + `add_task()` with full metadata

todo_agent/infrastructure/todo_shell.py

@@ -108,6 +108,10 @@ class TodoShell:
         """Add new task."""
         return self.execute(["todo.sh", "add", description])
 
+    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:
@@ -178,6 +182,10 @@ class TodoShell:
         """Archive completed tasks."""
         return self.execute(["todo.sh", "-f", "archive"])
 
+    def get_help(self) -> str:
+        """Get todo.sh help output."""
+        return self.execute(["todo.sh", "help"], suppress_color=False)
+
     def set_due_date(self, task_number: int, due_date: str) -> str:
         """
         Set or update due date for a task by intelligently rewriting it.
@@ -276,6 +284,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

@@ -225,6 +225,23 @@ class CLI:
         self.console.print(table)
         self.console.print("Or just type your request naturally!", style="italic green")
 
+    def _print_todo_help(self) -> None:
+        """Print todo.sh help information."""
+        try:
+            # Get todo.sh help output
+            help_output = self.todo_shell.get_help()
+            formatted_output = TaskFormatter.format_task_list(help_output)
+            help_panel = PanelFormatter.create_task_panel(
+                formatted_output, title="📋 Todo.sh Help"
+            )
+            self.console.print(help_panel)
+        except Exception as e:
+            self.logger.error(f"Error getting todo.sh help: {e!s}")
+            error_msg = ResponseFormatter.format_error(
+                f"Failed to get todo.sh help: {e!s}"
+            )
+            self.console.print(error_msg)
+
     def _print_about(self) -> None:
         """Print about information in a formatted panel."""
         about_panel = PanelFormatter.create_about_panel()
@@ -280,6 +297,37 @@ class CLI:
                 if not user_input:
                     continue
 
+                # Handle todo.sh passthrough commands (starting with /)
+                if user_input.startswith("/"):
+                    self.logger.debug(
+                        f"Processing todo.sh passthrough command: {user_input}"
+                    )
+                    try:
+                        # Remove the leading / and execute as todo.sh command
+                        todo_command = user_input[1:].strip()
+                        if not todo_command:
+                            self.console.print(
+                                ResponseFormatter.format_error("Empty todo.sh command")
+                            )
+                            continue
+
+                        # Execute the todo.sh command directly
+                        output = self.todo_shell.execute(
+                            ["todo.sh", *todo_command.split()]
+                        )
+                        formatted_output = TaskFormatter.format_task_list(output)
+                        task_panel = PanelFormatter.create_task_panel(
+                            formatted_output, title="📋 Todo.sh Output"
+                        )
+                        self.console.print(task_panel)
+                    except Exception as e:
+                        self.logger.error(f"Error executing todo.sh command: {e!s}")
+                        error_msg = ResponseFormatter.format_error(
+                            f"Todo.sh command failed: {e!s}"
+                        )
+                        self.console.print(error_msg)
+                    continue
+
                 # Handle special commands
                 if user_input.lower() == "clear":
                     self.logger.info("User requested conversation clear")
@@ -302,6 +350,11 @@ class CLI:
                     self._print_help()
                     continue
 
+                if user_input.lower() == "todo-help":
+                    self.logger.debug("User requested todo.sh help")
+                    self._print_todo_help()
+                    continue
+
                 if user_input.lower() == "about":
                     self.logger.debug("User requested about information")
                     self._print_about()

todo_agent/interface/formatters.py

@@ -357,6 +357,7 @@ class TableFormatter:
             ("clear", "Clear conversation history"),
             ("stats", "Show conversation statistics"),
             ("help", "Show this help message"),
+            ("todo-help", "Show todo.sh help"),
             ("about", "Show application information"),
             ("list", "List all tasks (no LLM interaction)"),
             ("done", "List completed tasks (no LLM interaction)"),

todo_agent/interface/tools.py

@@ -16,7 +16,7 @@ Task Management Tools:
 - append_to_task(task_number, text) - Add text to end of existing task
 - prepend_to_task(task_number, text) - Add text to beginning of existing task
 - delete_task(task_number, term?) - Delete entire task or remove specific term
-- created_completed_task(description, completion_date?, project?, context?) - Create task and immediately mark as completed
+- create_completed_task(description, completion_date?, project?, context?) - Create task and immediately mark as completed
 
 Priority Management Tools:
 - set_priority(task_number, priority) - Set or change task priority (A-Z)
@@ -26,6 +26,7 @@ Task Modification Tools:
 - set_due_date(task_number, due_date) - Set or update due date for a task by intelligently rewriting it (use empty string to remove due date)
 - set_context(task_number, context) - Set or update context for a task by intelligently rewriting it (use empty string to remove context)
 - set_project(task_number, projects) - Set or update projects for a task by intelligently rewriting it (handles array of projects with add/remove operations)
+- set_parent(task_number, parent_number) - Set or update parent task number for a task by intelligently rewriting it (use None to remove parent)
 
 Utility Tools:
 - move_task(task_number, destination, source?) - Move task between files
@@ -176,6 +177,10 @@ class ToolCallHandler:
                                 "type": "string",
                                 "description": "Optional duration estimate in format: minutes (e.g., '30m'), hours (e.g., '2h'), or days (e.g., '1d'). Use for time planning and task prioritization.",
                             },
+                            "parent_number": {
+                                "type": "integer",
+                                "description": "Optional parent task number (required for subtasks)",
+                            },
                         },
                         "required": ["description"],
                     },
@@ -254,12 +259,12 @@ class ToolCallHandler:
                                 "type": "integer",
                                 "description": "The line number of the task to modify (required)",
                             },
-                            "text_to_append": {
+                            "text": {
                                 "type": "string",
                                 "description": "Text to add to the end of the task (required)",
                             },
                         },
-                        "required": ["task_number", "text_to_append"],
+                        "required": ["task_number", "text"],
                     },
                 },
                 "progress_description": "📝 Adding notes to task #{task_number}...",
@@ -474,6 +479,39 @@ class ToolCallHandler:
                 },
                 "progress_description": "🏷️ Setting project tags for task #{task_number}...",
             },
+            {
+                "type": "function",
+                "function": {
+                    "name": "set_parent",
+                    "description": (
+                        "Set or update the parent task number for an EXISTING task by intelligently rewriting it. "
+                        "USE CASE: Call this when user wants to add, change, or remove a parent task relationship on an existing task. "
+                        "NOT FOR: Creating new tasks, completing tasks, or any other task operations. "
+                        "This preserves all existing task components (priority, projects, contexts, due date, etc.) "
+                        "while updating or adding the parent relationship. Use None to remove the parent. "
+                        "PREFERRED METHOD: Use this instead of append_to_task() when adding parent tags (parent:XX). "
+                        "This tool properly manages parent relationships and prevents formatting issues. "
+                        "IMPORTANT: Use list_tasks() first "
+                        "to find the correct task number if user doesn't specify it. "
+                        "Parent task numbers should be provided as integers (e.g., 12 not 'parent:12')."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "task_number": {
+                                "type": "integer",
+                                "description": "The line number of the task to modify (required)",
+                            },
+                            "parent_number": {
+                                "type": "integer",
+                                "description": "Parent task number to set, or null to remove parent (required)",
+                            },
+                        },
+                        "required": ["task_number", "parent_number"],
+                    },
+                },
+                "progress_description": "🔗 Setting parent task {parent_number} for task #{task_number}...",
+            },
             {
                 "type": "function",
                 "function": {
@@ -585,16 +623,17 @@ class ToolCallHandler:
             {
                 "type": "function",
                 "function": {
-                    "name": "created_completed_task",
+                    "name": "create_completed_task",
                     "description": (
                         "Create a task and immediately mark it as completed. "
-                        "USE CASE: Call this when user says they completed something on a specific date (e.g., 'I did the laundry today', 'I finished the report yesterday', 'I cleaned the garage last week') "
+                        "USE CASE: WHEN NO MATCH IS FOUND! Call this when user says they completed something on a specific date (e.g., 'I did the laundry today', 'I finished the report yesterday', 'I cleaned the garage last week') "
                         "and you have already researched existing tasks to determine no match exists. "
-                        "WORKFLOW: 1) Use list_tasks() to search for existing tasks, 2) Use list_completed_tasks() to verify it's not already done, "
-                        "3) If no match found, call this tool to create and complete the task in one operation. "
+                        "WORKFLOW: 1) Use list_tasks() to search for existing tasks, "
+                        "2) Use list_completed_tasks() to verify it's not already done, "
+                        "3) If a match is found, use complete_task() to mark it complete, "
+                        "4) If no match found, call this tool to create and complete the task in one operation. "
                         "STRATEGIC CONTEXT: This is a convenience tool for the common pattern of 'I did X on [date]' - "
-                        "it creates a task with the specified completion date and immediately marks it complete. "
-                        "The LLM should handle the research and decision-making about whether to use this tool."
+                        "when no task match is found, it creates a task with the specified completion date and immediately marks it complete. "
                     ),
                     "parameters": {
                         "type": "object",
@@ -615,6 +654,10 @@ class ToolCallHandler:
                                 "type": "string",
                                 "description": "Optional context name (without the @ symbol) for new task creation",
                             },
+                            "parent_number": {
+                                "type": "integer",
+                                "description": "Optional parent task number (required for subtasks)",
+                            },
                         },
                         "required": ["description"],
                     },
@@ -897,11 +940,12 @@ class ToolCallHandler:
             "set_due_date": self.todo_manager.set_due_date,
             "set_context": self.todo_manager.set_context,
             "set_project": self.todo_manager.set_project,
+            "set_parent": self.todo_manager.set_parent,
             "move_task": self.todo_manager.move_task,
             "archive_tasks": self.todo_manager.archive_tasks,
             "parse_date": self._parse_date,
             "get_calendar": self._get_calendar,
-            "created_completed_task": self.todo_manager.created_completed_task,
+            "create_completed_task": self.todo_manager.create_completed_task,
             "restore_completed_task": self.todo_manager.restore_completed_task,
         }
 

todo_agent/main.py

@@ -11,9 +11,12 @@ from .interface.cli import CLI
 
 def main() -> None:
     """Main application entry point."""
+    from ._version import __version__
+
     parser = argparse.ArgumentParser(
-        description="Todo.sh LLM Agent - Natural language task management",
+        description=f"Todo.sh LLM Agent - Natural language task management (v{__version__})",
         formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,
         epilog="""
 Examples:
   todo-agent                    # Interactive mode
@@ -23,6 +26,21 @@ Examples:
         """,
     )
 
+    parser.add_argument(
+        "--version",
+        "-v",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show version information and exit",
+    )
+
+    parser.add_argument(
+        "--help",
+        "-h",
+        action="help",
+        help="Show this help message and exit",
+    )
+
     parser.add_argument(
         "command",
         nargs="?",
@@ -37,11 +55,28 @@ Examples:
         if args.command:
             # Single command mode
             # Handle special commands that don't need LLM processing
-            if args.command.lower() in ["help", "about"]:
+            if args.command.lower() in ["help", "about", "todo-help"]:
                 if args.command.lower() == "help":
                     cli._print_help()
                 elif args.command.lower() == "about":
                     cli._print_about()
+                elif args.command.lower() == "todo-help":
+                    cli._print_todo_help()
+            elif args.command.startswith("/"):
+                # Handle todo.sh passthrough commands
+                try:
+                    # Remove the leading / and execute as todo.sh command
+                    todo_command = args.command[1:].strip()
+                    if not todo_command:
+                        print("Error: Empty todo.sh command")
+                        sys.exit(1)
+
+                    # Execute the todo.sh command directly
+                    output = cli.todo_shell.execute(["todo.sh", *todo_command.split()])
+                    print(output)
+                except Exception as e:
+                    print(f"Error: Todo.sh command failed: {e}")
+                    sys.exit(1)
             else:
                 # Process through LLM
                 response = cli.run_single_request(args.command)

{todo_agent-0.3.3.dist-info → todo_agent-0.3.6.dist-info}/METADATA

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