todo-agent 0.2.6__py3-none-any.whl → 0.2.8__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.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.8'
+__version_tuple__ = version_tuple = (0, 2, 8)
 
 __commit_id__ = commit_id = None

todo_agent/core/conversation_manager.py

@@ -35,14 +35,16 @@ class ConversationManager:
     """Manages conversation state and memory for LLM interactions."""
 
     def __init__(
-        self, max_tokens: int = 16000, max_messages: int = 50, model: str = "gpt-4"
+        self, max_tokens: int = 32000, max_messages: int = 50, model: str = "gpt-4"
     ):
         self.history: List[ConversationMessage] = []
         self.max_tokens = max_tokens
         self.max_messages = max_messages
         self.system_prompt: Optional[str] = None
         self.token_counter = get_token_counter(model)
-        self._total_tokens = 0  # Running total of tokens in conversation
+        self._total_tokens: int = 0  # Running total of tokens in conversation
+        self._tools_tokens: int = 0  # Cache for tools token count
+        self._last_tools_hash: Optional[int] = None  # Track if tools have changed
 
     def add_message(
         self,
@@ -140,10 +142,44 @@ class ConversationManager:
                 self._total_tokens -= message.token_count
             self.history.pop(index)
 
-    def _trim_if_needed(self) -> None:
+    def get_request_tokens(self, tools: List[Dict[str, Any]]) -> int:
+        """
+        Get total request tokens (conversation + tools).
+
+        Args:
+            tools: Current tool definitions
+
+        Returns:
+            Total request tokens
+        """
+        # Check if tools have changed
+        tools_hash = hash(str(tools))
+        if tools_hash != self._last_tools_hash:
+            self._tools_tokens = self.token_counter.count_tools_tokens(tools)
+            self._last_tools_hash = tools_hash
+
+        return self._total_tokens + self._tools_tokens
+
+    def update_request_tokens(self, actual_prompt_tokens: int) -> None:
+        """
+        Update the conversation with actual token count from API response.
+
+        Args:
+            actual_prompt_tokens: Actual prompt tokens used by the API
+        """
+        # Calculate tools tokens by subtracting conversation tokens
+        tools_tokens = actual_prompt_tokens - self._total_tokens
+        if tools_tokens >= 0:
+            self._tools_tokens = tools_tokens
+        # Note: logger not available in this context, so we'll handle logging in the calling code
+
+    def _trim_if_needed(self, tools: Optional[List[Dict[str, Any]]] = None) -> None:
         """
         Trim conversation history if it exceeds token or message limits.
         Preserves most recent messages and system prompt.
+
+        Args:
+            tools: Optional tools for request token calculation
         """
         # Check message count limit
         if len(self.history) > self.max_messages:
@@ -160,8 +196,10 @@ class ConversationManager:
             # Recalculate total tokens after message count trimming
             self._recalculate_total_tokens()
 
-        # Check token limit - remove oldest non-system messages until under limit
-        while self._total_tokens > self.max_tokens and len(self.history) > 2:
+        # Check token limit using request tokens if tools provided
+        current_tokens = self.get_request_tokens(tools) if tools else self._total_tokens
+
+        while current_tokens > self.max_tokens and len(self.history) > 2:
             # Find oldest non-system message to remove
             for i, msg in enumerate(self.history):
                 if msg.role != MessageRole.SYSTEM:
@@ -171,6 +209,11 @@ class ConversationManager:
                 # No non-system messages found, break to avoid infinite loop
                 break
 
+            # Recalculate request tokens
+            current_tokens = (
+                self.get_request_tokens(tools) if tools else self._total_tokens
+            )
+
     def _recalculate_total_tokens(self) -> None:
         """Recalculate total token count from scratch (used after major restructuring)."""
         self._total_tokens = 0
@@ -219,10 +262,15 @@ class ConversationManager:
         self.history.insert(0, system_message)
         self._total_tokens += token_count
 
-    def get_conversation_summary(self) -> Dict[str, Any]:
+    def get_conversation_summary(
+        self, tools: Optional[List[Dict[str, Any]]] = None
+    ) -> Dict[str, Any]:
         """
         Get conversation statistics and summary.
 
+        Args:
+            tools: Optional tools for request token calculation
+
         Returns:
             Dictionary with conversation metrics
         """
@@ -256,6 +304,9 @@ class ConversationManager:
         return {
             "total_messages": len(self.history),
             "estimated_tokens": self._total_tokens,
+            "request_tokens": self.get_request_tokens(tools)
+            if tools
+            else self._total_tokens,
             "user_messages": len(
                 [msg for msg in self.history if msg.role == MessageRole.USER]
             ),

todo_agent/core/todo_manager.py

@@ -19,6 +19,7 @@ class TodoManager:
         project: Optional[str] = None,
         context: Optional[str] = None,
         due: Optional[str] = None,
+        recurring: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
         # Validate and sanitize inputs
@@ -54,6 +55,31 @@ class TodoManager:
                     f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
                 )
 
+        if recurring:
+            # Validate recurring format
+            if not recurring.startswith("rec:"):
+                raise ValueError(
+                    f"Invalid recurring format '{recurring}'. Must start with 'rec:'."
+                )
+            # Basic validation of recurring syntax
+            parts = recurring.split(":")
+            if len(parts) < 2 or len(parts) > 3:
+                raise ValueError(
+                    f"Invalid recurring format '{recurring}'. Expected 'rec:frequency' or 'rec:frequency:interval'."
+                )
+            frequency = parts[1]
+            if frequency not in ["daily", "weekly", "monthly", "yearly"]:
+                raise ValueError(
+                    f"Invalid frequency '{frequency}'. Must be one of: daily, weekly, monthly, yearly."
+                )
+            if len(parts) == 3:
+                try:
+                    interval = int(parts[2])
+                    if interval < 1:
+                        raise ValueError("Interval must be at least 1.")
+                except ValueError:
+                    raise ValueError(f"Invalid interval '{parts[2]}'. Must be a positive integer.")
+
         # Build the full task description with priority, project, and context
         full_description = description
 
@@ -69,6 +95,9 @@ class TodoManager:
         if due:
             full_description = f"{full_description} due:{due}"
 
+        if recurring:
+            full_description = f"{full_description} {recurring}"
+
         self.todo_shell.add(full_description)
         return f"Added task: {full_description}"
 

todo_agent/infrastructure/inference.py

@@ -187,6 +187,18 @@ class Inference:
                 messages=messages, tools=self.tool_handler.tools
             )
 
+            # Extract actual token usage from API response
+            usage = response.get("usage", {})
+            actual_prompt_tokens = usage.get("prompt_tokens", 0)
+            actual_completion_tokens = usage.get("completion_tokens", 0)
+            actual_total_tokens = usage.get("total_tokens", 0)
+
+            # Update conversation manager with actual token count
+            self.conversation_manager.update_request_tokens(actual_prompt_tokens)
+            self.logger.debug(
+                f"Updated with actual API tokens: prompt={actual_prompt_tokens}, completion={actual_completion_tokens}, total={actual_total_tokens}"
+            )
+
             # Handle multiple tool calls in sequence
             tool_call_count = 0
             while True:
@@ -237,6 +249,14 @@ class Inference:
                     messages=messages, tools=self.tool_handler.tools
                 )
 
+                # Update with actual tokens from subsequent API calls
+                usage = response.get("usage", {})
+                actual_prompt_tokens = usage.get("prompt_tokens", 0)
+                self.conversation_manager.update_request_tokens(actual_prompt_tokens)
+                self.logger.debug(
+                    f"Updated with actual API tokens after tool calls: prompt={actual_prompt_tokens}"
+                )
+
             # Calculate and log total thinking time
             end_time = time.time()
             thinking_time = end_time - start_time
@@ -270,7 +290,9 @@ class Inference:
         Returns:
             Dictionary with conversation metrics
         """
-        return self.conversation_manager.get_conversation_summary()
+        return self.conversation_manager.get_conversation_summary(
+            self.tool_handler.tools
+        )
 
     def clear_conversation(self) -> None:
         """Clear conversation history."""

todo_agent/infrastructure/ollama_client.py

@@ -72,12 +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,12 +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,160 +1,334 @@
-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
-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 (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
-
-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..."
-
-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].
-- 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
-- Ambiguous requests: Show numbered options
-- 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"
-- 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}
+STRATEGIC TODO.SH ASSISTANT
+
+Context: {current_datetime} | {calendar_output}
+
+You operate through processing cycles: query -> strategic analysis + tool calls -> results -> continue until complete.
+
+CORE PRINCIPLES
+- Keep responses concise and to-the-point. Default to brevity unless user explicitly requests detail
+- ALWAYS organize tasks by context and project for maximum user utility
+- Present in natural language with strategic insights, never raw todo.txt format
+- Include concise reasoning for all decisions and suggestions
+- Make confident and specific recommendations
+- Lead with the answer then follow with minimal supporting information afterward
+- Prose is always preferred to formatted lists or formatting in general
+
+OUTPUT FORMATTING
+- Use clear hierarchical structure with consistent indentation
+- Employ unicode bullet points (•, ◦, ▪, ▫) and numbered lists for scannable content
+- Separate distinct sections with blank lines for visual breathing room
+- Lead with the most important information first
+- Use active voice and direct language
+- Structure complex information in digestible chunks
+
+PRIMARY DECISION FLOW
+
+Gate 1: Data Foundation
+Have the data needed for intelligent response?
+- Missing task data -> list_tasks() + context discovery  
+- Need project/context scope -> list_projects() + list_contexts()
+- Completion-related -> Include list_completed_tasks()
+
+Gate 2: Strategic Intent Recognition
+What strategic outcome does the user need?
+
+DEFAULT BEHAVIOR: Task Organization and/or Suggestion
+ALWAYS organize tasks by context and project for maximum user utility:
+
+**Context-Based Organization:**
+- Group tasks by context (@home, @office, @phone, etc.) with clear section headers
+- Within each context, group by project (+work, +health, +bills, etc.) with clear sub-headers
+- Use consistent indentation and visual hierarchy
+
+**Priority and Timing Display:**
+- Show priorities prominently with unicode symbols (★ High, ◦ Medium, ▪ Low)
+- Display due dates with clear formatting and urgency indicators (⚠ urgent)
+- Highlight quick wins (⚡ 2-minute tasks) and high-value opportunities
+
+**Strategic Presentation:**
+- Apply strategic intelligence to suggest optimal task sequences
+- Present in natural language with strategic insights, never raw todo.txt format
+- Use unicode bullet points and numbered lists for easy scanning
+- Include brief strategic commentary for complex task relationships
+- ACTIVATE Completion Date Intelligence Engine for all date-related suggestions
+
+TACTICAL: Single task operation (add, complete, modify)
+Execute with verification protocols
+
+STRATEGIC: Planning, prioritization, workflow optimization  
+Activate strategic intelligence modules
+
+EXPLORATORY: Understanding current state, seeking guidance
+Provide intelligent analysis with actionable insights
+
+Gate 3: Execution Protocols
+
+Task Creation Protocol:
+DISCOVER: Current tasks + completed tasks
+ANALYZE: Semantic duplicates? (similar intent/keywords)
+INFER: High confidence context/timing from:
+  - Explicit temporal: "tomorrow", "by Friday" 
+  - Task nature: bills->payment cycles, work->business hours
+  - Existing patterns: match similar task contexts
+  - Calendar context: work days, weekends, holidays
+  - ACTIVATE Completion Date Intelligence Engine for date inference
+DECIDE:
+  - Clear intent + high confidence -> Create immediately
+  - Semantic duplicate found -> "Similar task exists: [task]. Add anyway or modify existing?"
+  - Ambiguous context -> Ask specific clarification
+  - Low confidence inference -> Verify before acting
+
+Completion Date Intelligence Engine
+When inferring convenient and realistic completion dates:
+
+Temporal Pattern Recognition:
+- Work tasks: Due by end of business week (Friday) unless urgent
+- Personal tasks: Weekend availability for non-work contexts
+- Bills/payments: 3-5 days before actual due date for buffer
+- Health appointments: 1-2 weeks lead time for scheduling
+- Errands: Group by location context (@grocery, @post-office)
+- Calls: Business hours for work, flexible for personal
+
+REASONING REQUIREMENT: Always provide concise explanation for date suggestions including calendar reference
+
+Strategic Timing Optimization:
+- High-priority tasks: Today or tomorrow for immediate impact
+- Medium-priority: End of current week or beginning of next
+- Low-priority: End of current month or next milestone
+- Dependent tasks: After prerequisite completion + reasonable buffer
+- Batch opportunities: Group similar tasks on same day/context
+
+Calendar-Aware Scheduling and Suggestion:
+- Avoid weekends for work tasks unless explicitly requested
+- Consider holidays and observed days off
+- Account for travel days and unavailable periods
+- Respect recurring commitments and meeting patterns
+- Buffer time for unexpected interruptions
+
+Context-Driven Deadlines:
+- @phone tasks: Business hours for work, flexible for personal
+- @office tasks: Work days only, avoid Mondays for non-urgent
+- @home tasks: Evenings and weekends preferred
+- @errands: Group by location efficiency and operating hours
+- @computer tasks: Consider energy levels and focus requirements
+
+Realistic Buffer Strategy:
+- Critical deadlines: 2-3 day buffer for unexpected issues
+- Complex tasks: 50% time buffer for scope creep
+- New task types: Conservative estimates until patterns emerge
+
+Task Completion Protocol:
+SEARCH: Find semantic matches in active tasks
+VERIFY: Not already in completed tasks
+MATCH:
+  - Single clear match -> Complete immediately + suggest next steps
+  - Multiple candidates -> Show numbered options with context
+  - Fuzzy match -> "Did you mean: [closest match]?"
+  - No match -> "No matching active tasks found. Recent completions?"
+
+STRATEGIC INTELLIGENCE MODULES
+
+Priority Analysis Engine
+When users need prioritization guidance:
+
+Dependency Mapping: Identify blockers and enablers
+- Tasks that unlock others get higher priority
+- Map project relationships and prerequisite chains
+- Flag bottlenecks that delay multiple downstream tasks
+
+Impact Assessment: Apply Eisenhower Matrix thinking
+- Q1 (Urgent+Important): Handle immediately with due date pressure
+- Q2 (Important): Schedule based on capacity and dependencies  
+- Q3 (Urgent): Consider delegation potential or quick resolution
+- Q4 (Low value): Suggest elimination or deferral
+
+Effort Optimization: Balance quick wins with high-impact work
+- Prioritize <=10-minute tasks for immediate completion
+- Batch similar contexts (@calls, @errands) for efficiency
+- Sequence dependent tasks in logical order
+
+Task Relationship Intelligence
+Present tasks with strategic context:
+
+Dependency Chains: "After completing X, you can start Y because..."
+Project Coherence: Group related tasks showing workflow progression  
+Context Optimization: "While @phone, also handle [related calls]"
+Timing Intelligence: Consider work patterns, energy levels, external constraints
+- ACTIVATE Completion Date Intelligence Engine for dependency timing and sequencing
+
+Natural Language Understanding
+Sophisticated inference from user language:
+
+Semantic Completion Matching: "finished the presentation" matches "+work Present quarterly results @office"
+Context Inference: "dentist" -> +health @phone due:[reasonable appointment timeframe]  
+Urgency Recognition: "urgent", "asap" -> today; "sometime" -> end of current period
+Project Disambiguation: Use existing task patterns to resolve ambiguous project references
+- ACTIVATE Completion Date Intelligence Engine for temporal language interpretation
+
+Completion Date Integration Protocol
+When any timing or scheduling decisions are needed:
+
+Gate Integration:
+- Gate 1: Use completion date intelligence to determine what data is needed
+- Gate 2: Apply completion date patterns to understand strategic intent
+- Gate 3: Integrate completion date logic into all execution protocols
+
+Protocol Activation Triggers:
+- Task creation with temporal language ("tomorrow", "next week", "by Friday")
+- Priority changes that affect timing
+- Dependency chain analysis requiring sequencing
+- Calendar-aware task organization
+- Strategic planning and workflow optimization requests
+
+Cross-Module Coordination:
+- Priority Analysis Engine: Use completion dates to inform priority decisions
+- Task Relationship Intelligence: Sequence tasks based on realistic completion dates
+- Natural Language Understanding: Interpret temporal expressions with completion date patterns
+- Response Intelligence: Present timing suggestions using completion date logic
+
+RESPONSE INTELLIGENCE
+
+Adaptive Response Calibration
+Simple status queries: Brief, direct answers without verbose explanation
+Complex strategic requests: Detailed analysis with clear reasoning
+Task lists: Show logical flow (dependencies -> priorities -> quick wins) never just due dates
+Completion actions: Confirm completion + suggest logical next steps from dependencies
+
+Completion Date Reasoning Protocol
+When suggesting completion dates, ALWAYS include concise reasoning:
+
+Context-Based Explanations:
+- @phone tasks: "Business hours for work calls"
+- @office tasks: "Work days only, avoiding Mondays"
+- @home tasks: "Evenings/weekends for personal time"
+- @errands: "Grouped by location efficiency"
+- Bills: "3-day buffer before actual due date"
+
+Strategic Reasoning:
+- Dependencies: "After [prerequisite] completes"
+- Batching: "Grouped with similar [context] tasks"
+- Priority alignment: "High priority → immediate timeline"
+- Calendar awareness: "Avoiding [holiday/travel/meeting]"
+- Buffer strategy: "Conservative estimate for [complexity/uncertainty]"
+
+Reasoning Format: "[Date] because [concise explanation]"
+Example: "Due Friday because work task, end of business week"
+
+
+RESPONSE PATTERNS
+- "What should I do next?" → Recommend 1-2 top priority tasks with brief reasoning
+- "List tasks" → ALWAYS organize by context and project with strategic insights
+- "Show me everything" → Provide comprehensive view organized by context and project
+- Ambiguous or unclear requests → Default to task organization and optimization
+- Basic task requests → Apply strategic intelligence and organization
+- NEVER present raw task lists - always organize and provide strategic context
+- Use unicode symbols sparingly: ★ for priorities, ⚡ for quick wins, ⚠ for urgent
+- Avoid verbose explanations - get to the point quickly
+- Limit strategic commentary to essential insights only
+
+Response Transparency: Include concise reasoning in content field for tool calls
+- Before using tools: Brief explanation of what you're doing
+- During tool execution: Minimal context for each action
+- After completion: Concise summary of what was accomplished
+
+Error Recovery Patterns
+Empty results: "No tasks found. Would you like to [create/search broader/see completed]?"  
+Ambiguous requests: Present specific options with context, never generic confusion
+Tool failures: Clear explanation + alternative approaches
+- Keep error messages brief and actionable
+
+Conversational Intelligence
+Task presentation: ALWAYS organize by context and project, convert to natural language
+
+**Structured Task Display:**
+- Group by context with clear headers: "@Home", "@Office", "@Phone", etc.
+- Within each context, group by project with clear sub-headers: "+Work", "+Health", "+Bills", etc.
+- Convert todo.txt format to natural language with strategic insights
+- Example transformation:
+  - Raw: `(A) 2024-08-30 Call dentist +health @phone due:2024-09-02`
+  - Formatted: "★ Call the dentist (high priority, due Monday) - health appointment"
+
+**Enhanced Context Integration:**
+- Calendar integration: Reference calendar context when suggesting timing with clear formatting
+- Dependency narration: Explain task relationships with clear flow indicators
+- Strategic coaching: Offer brief productivity insights with actionable formatting
+
+**Visual Organization Standards:**
+- Apply clear visual hierarchy with consistent indentation and spacing
+- Include brief strategic commentary in separate, clearly formatted sections
+- ACTIVATE Completion Date Intelligence Engine for all timing suggestions and explanations
+- NEVER present raw task lists - always provide organized, strategic view
+
+RECURRING TASK INTELLIGENCE
+When encountering "rec:" syntax in task descriptions or the user indicates repeated tasks:
+- Parse frequency patterns: rec:daily, rec:weekly, rec:monthly, rec:yearly
+- Support intervals: rec:weekly:2 (every 2 weeks), rec:monthly:3 (every 3 months)
+- Natural language patterns: "daily", "weekly", "every Monday", "monthly report"
+- When completing recurring tasks, automatically generate next occurrence
+- Calculate appropriate due dates for next instances using Completion Date Intelligence Engine
+- Preserve all task metadata (priority, project, context) in new instances
+- Handle edge cases: leap years, month boundaries, weekday patterns
+
+Recurring Task Completion Protocol:
+1. Detect when user completes a recurring task
+2. Find the original recurring task in active tasks
+3. Mark it complete using complete_task()
+4. Calculate next occurrence date based on frequency
+5. Create new task instance with same metadata using add_task()
+6. Preserve recurring pattern in new task description
+
+Frequency Calculation Examples:
+- rec:daily → Next day from completion date
+- rec:weekly → Next same weekday from completion date  
+- rec:monthly → Same day next month (adjust for month boundaries)
+- rec:yearly → Same date next year (handle leap years)
+- rec:weekly:2 → Every 2 weeks from completion date
+- rec:monthly:3 → Every 3 months from completion date
+
+CORE BEHAVIORAL RULES (Hierarchical)
+
+1. Data integrity: Only reference tool-returned data, never hallucinate
+2. Strategic thinking: Consider broader context and dependencies
+3. Intelligent inference: Act on high confidence, verify medium confidence, ask about low confidence  
+4. Efficiency first: Minimize user friction while maintaining accuracy
+5. Response transparency: Include concise reasoning in content field for debugging and user understanding
+6. Default to organization: When intent is unclear, organize and optimize the task list
+7. Completion date reasoning: Always explain date suggestions with concise rationale
+8. Recurring task intelligence: Automatically handle recurring patterns and regeneration
+
+TODO.TXT FORMAT COMPLIANCE
+Priority: (A) (B) (C) | Projects: +name | Contexts: @location
+Due dates: due:YYYY-MM-DD | Completion: x YYYY-MM-DD description
+Recurring tasks: rec:frequency[:interval] (e.g., rec:daily, rec:weekly:2, rec:monthly)
+Single symbols only (never ++project or @@context)
+Do not duplicate elements such as +context or (PRIORITY) within a single task description.
+
+Example recurring task format:
+(A) Take vitamins +health @home rec:daily due:2025-01-15
+
+TOOL CALL FORMAT
+
+IMPORTANT: Include concise reasoning in the content field when using tools. 
+A reasoning statement in "content" is helpful to align with protocol.
+
+ORGANIZATION TOOL USAGE:
+ALWAYS organize tasks by context and project for maximum user utility:
+1. list_tasks() - Get current task state
+2. list_contexts() - Understand available contexts for grouping
+3. list_projects() - Understand available projects for sub-grouping
+4. get_overview() - Analyze task distribution and statistics
+5. Present organized view with strategic insights:
+   - Group by context (@home, @office, @phone, etc.) and convenient completion date
+   - Within each context, group by project (+work, +health, +bills, etc.)
+   - Show priorities and due dates prominently
+   - Highlight quick wins and high-value opportunities
+   - Provide brief strategic insights about task distribution and optimization
+
+CONTENT: [Brief reasoning about what needs to be done - this will be logged for debugging]
+STRATEGY: [Strategic objective for this cycle]
+REASONING: [Why these tools in this sequence]
+NEXT: [What I'll do with the results]
+
+[Tool calls follow]
+
+Available Tools: {tools_section}

todo_agent/interface/cli.py

@@ -138,8 +138,8 @@ class CLI:
         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)
+        summary = self.inference.get_conversation_summary()
+        current_tokens = summary.get("request_tokens", 0)  # Use request_tokens
         current_messages = summary.get("total_messages", 0)
 
         # Get limits from conversation manager
@@ -209,9 +209,7 @@ 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}")

todo_agent/interface/formatters.py

@@ -36,8 +36,6 @@ class TaskFormatter:
         formatted_text = Text()
         task_count = 0
 
-
-
         for line in lines:
             line = line.strip()
             # Skip empty lines, separators, and todo.sh's own summary line
@@ -57,8 +55,6 @@ class TaskFormatter:
 
         return formatted_text
 
-
-
     @staticmethod
     def format_completed_tasks(raw_tasks: str) -> Text:
         """
@@ -77,8 +73,6 @@ class TaskFormatter:
         formatted_text = Text()
         task_count = 0
 
-
-
         for line in lines:
             line = line.strip()
             # Skip empty lines, separators, and todo.sh's own summary line
@@ -97,8 +91,6 @@ class TaskFormatter:
 
         return formatted_text
 
-
-
     @staticmethod
     def _format_single_task(task_line: str, task_number: int) -> str:
         """
@@ -404,7 +396,9 @@ class PanelFormatter:
         )
 
     @staticmethod
-    def create_task_panel(content: str | Text, 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

todo_agent/interface/tools.py

@@ -1,5 +1,31 @@
 """
 Tool definitions and schemas for LLM function calling.
+
+AVAILABLE TOOLS:
+
+Discovery Tools (Call FIRST):
+- list_projects() - Get all available projects from todo.txt
+- list_contexts() - Get all available contexts from todo.txt
+- list_tasks(filter?) - List current tasks with optional filtering
+- list_completed_tasks(filter?, project?, context?, text_search?, date_from?, date_to?) - List completed tasks with optional filtering
+
+Task Management Tools:
+- add_task(description, priority?, project?, context?, due?) - Add new task to todo.txt
+- complete_task(task_number) - Mark task as complete by line number
+- replace_task(task_number, new_description) - Replace entire task content
+- 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
+
+Priority Management Tools:
+- set_priority(task_number, priority) - Set or change task priority (A-Z)
+- remove_priority(task_number) - Remove priority from task
+
+Utility Tools:
+- get_overview() - Show task statistics and summary
+- move_task(task_number, destination, source?) - Move task between files
+- archive_tasks() - Archive completed tasks from todo.txt to done.txt
+- get_calendar(month, year) - Get calendar for specific month and year
 """
 
 import subprocess
@@ -173,7 +199,8 @@ class ToolCallHandler:
                         "ask the user if they want to add a new task or modify an existing one. "
                         "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, "
+                        "DUE DATE INFERENCE: Use parse_date() tool to convert any temporal expressions to YYYY-MM-DD format. "
+                        "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 "
@@ -201,7 +228,11 @@ class ToolCallHandler:
                             },
                             "due": {
                                 "type": "string",
-                                "description": "Optional due date in YYYY-MM-DD format. Automatically inferred from natural language expressions like 'tomorrow', 'next week', 'by Friday', 'urgent', 'asap'",
+                                "description": "Optional due date in YYYY-MM-DD format. Use parse_date() tool to convert natural language expressions like 'tomorrow', 'next week', 'by Friday' to YYYY-MM-DD format",
+                            },
+                            "recurring": {
+                                "type": "string",
+                                "description": "Optional recurring pattern in rec:frequency[:interval] format (e.g., 'rec:daily', 'rec:weekly:2', 'rec:monthly'). Use for tasks that repeat automatically.",
                             },
                         },
                         "required": ["description"],
@@ -435,13 +466,27 @@ class ToolCallHandler:
             {
                 "type": "function",
                 "function": {
-                    "name": "deduplicate_tasks",
+                    "name": "parse_date",
                     "description": (
-                        "Remove duplicate tasks from todo.txt. Use this when user wants "
-                        "to clean up duplicate entries or when you notice duplicate tasks "
-                        "in the list."
+                        "Convert natural language date expressions to YYYY-MM-DD format. "
+                        "Use this when: "
+                        "1) User mentions weekdays like 'due on Monday', 'by Friday', 'next Tuesday', "
+                        "2) User uses relative dates like 'tomorrow', 'next week', 'in 3 days', "
+                        "3) User says 'this Monday' vs 'next Monday' and you need the exact date, "
+                        "4) You need to convert any temporal expression to a specific calendar date. "
+                        "This tool handles all date parsing to ensure accuracy and consistency. "
+                        "CRITICAL: Use this tool whenever you need to convert any date expression to YYYY-MM-DD format."
                     ),
-                    "parameters": {"type": "object", "properties": {}, "required": []},
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "date_expression": {
+                                "type": "string",
+                                "description": "The natural language date expression to parse (e.g., 'next Monday', 'tomorrow', 'by Friday', 'in 3 days')",
+                            },
+                        },
+                        "required": ["date_expression"],
+                    },
                 },
             },
             {
@@ -507,6 +552,115 @@ class ToolCallHandler:
 
             return calendar.month(year, month).strip()
 
+    def _parse_date(self, date_expression: str) -> str:
+        """
+        Parse natural language date expressions to YYYY-MM-DD format.
+
+        Args:
+            date_expression: Natural language date expression
+
+        Returns:
+            Date in YYYY-MM-DD format
+        """
+        try:
+            # Use the date command to parse natural language expressions
+            result = subprocess.run(
+                ["date", "-d", date_expression, "+%Y-%m-%d"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return result.stdout.strip()
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # Fallback to Python date parsing
+            import re
+            from datetime import datetime, timedelta
+
+            today = datetime.now()
+            date_expr = date_expression.lower().strip()
+
+            # Handle "next [weekday]" patterns
+            next_match = re.match(
+                r"next\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)",
+                date_expr,
+            )
+            if next_match:
+                weekday_name = next_match.group(1)
+                weekday_map = {
+                    "monday": 0,
+                    "tuesday": 1,
+                    "wednesday": 2,
+                    "thursday": 3,
+                    "friday": 4,
+                    "saturday": 5,
+                    "sunday": 6,
+                }
+                target_weekday = weekday_map[weekday_name]
+                days_ahead = target_weekday - today.weekday()
+                if days_ahead <= 0:  # Target day already happened this week
+                    days_ahead += 7
+                target_date = today + timedelta(days=days_ahead)
+                return target_date.strftime("%Y-%m-%d")
+
+            # Handle "this [weekday]" patterns
+            this_match = re.match(
+                r"this\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)",
+                date_expr,
+            )
+            if this_match:
+                weekday_name = this_match.group(1)
+                weekday_map = {
+                    "monday": 0,
+                    "tuesday": 1,
+                    "wednesday": 2,
+                    "thursday": 3,
+                    "friday": 4,
+                    "saturday": 5,
+                    "sunday": 6,
+                }
+                target_weekday = weekday_map[weekday_name]
+                days_ahead = target_weekday - today.weekday()
+                if days_ahead < 0:  # Target day already happened this week
+                    days_ahead += 7
+                target_date = today + timedelta(days=days_ahead)
+                return target_date.strftime("%Y-%m-%d")
+
+            # Handle "tomorrow"
+            if date_expr == "tomorrow":
+                return (today + timedelta(days=1)).strftime("%Y-%m-%d")
+
+            # Handle "in X days"
+            days_match = re.match(r"in\s+(\d+)\s+days?", date_expr)
+            if days_match:
+                days = int(days_match.group(1))
+                return (today + timedelta(days=days)).strftime("%Y-%m-%d")
+
+            # Handle "by [weekday]" - same as "next [weekday]"
+            by_match = re.match(
+                r"by\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)",
+                date_expr,
+            )
+            if by_match:
+                weekday_name = by_match.group(1)
+                weekday_map = {
+                    "monday": 0,
+                    "tuesday": 1,
+                    "wednesday": 2,
+                    "thursday": 3,
+                    "friday": 4,
+                    "saturday": 5,
+                    "sunday": 6,
+                }
+                target_weekday = weekday_map[weekday_name]
+                days_ahead = target_weekday - today.weekday()
+                if days_ahead <= 0:  # Target day already happened this week
+                    days_ahead += 7
+                target_date = today + timedelta(days=days_ahead)
+                return target_date.strftime("%Y-%m-%d")
+
+            # If we can't parse it, return today's date as fallback
+            return today.strftime("%Y-%m-%d")
+
     def _format_tool_signature(self, tool_name: str, arguments: Dict[str, Any]) -> str:
         """Format tool signature with parameters for logging."""
         if not arguments:
@@ -574,6 +728,7 @@ class ToolCallHandler:
             "move_task": self.todo_manager.move_task,
             "archive_tasks": self.todo_manager.archive_tasks,
             "deduplicate_tasks": self.todo_manager.deduplicate_tasks,
+            "parse_date": self._parse_date,
             "get_calendar": self._get_calendar,
         }
 

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

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

todo_agent-0.2.8.dist-info/RECORD

@@ -0,0 +1,29 @@
+todo_agent/__init__.py,sha256=RUowhd14r3tqB_7rl83unGV8oBjra3UOIl7jix-33fk,254
+todo_agent/_version.py,sha256=NCr4lkV1m1Jmisv_F-sazmV2gGdDIaVwqLyPwmjayqM,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=nRFcDMqZtumVipggzVe94Hwz9HDbc2CrTssk_HImwEI,13548
+todo_agent/core/exceptions.py,sha256=cPvvkIbKdI7l51wC7cE-ZxUi54P3nf2m7x2lMNMRFYM,399
+todo_agent/core/todo_manager.py,sha256=ZiCXfgS4kor3tdojwEKwD2G1lX-W9XuaoYvER82PHNM,10438
+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=PJouydXREgTIkZQVumdCvrwIbMdPR79baRV1W0s2TLA,11802
+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=RVgHqX37k7q5xEaEXdhcCv2HYQiszs1QV39RxFFMIas,5902
+todo_agent/infrastructure/openrouter_client.py,sha256=7qusHuOH-zMKMrQw98v3MKwSWUJwL0mZsdShSjeoti0,7121
+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=j7N8GhMbyRR7QqfkokbCJiElv6CdAhc22PVzY6vrucE,15880
+todo_agent/interface/__init__.py,sha256=vDD3rQu4qDkpvVwGVtkDzE1M4IiSHYzTif4GbYSFWaI,457
+todo_agent/interface/cli.py,sha256=C746b83dQTiyUfthcC-pngwsJlmXZAu10_hxsSOMzdM,12022
+todo_agent/interface/formatters.py,sha256=DiQLemndiuFWjLcBRPpu1wVnJcoYAFP8t_fJstOgaDs,18918
+todo_agent/interface/tools.py,sha256=_GlZwX09dYpqPB2Q-EsgGguA1PVl8_mRCdks6ucaJgU,39686
+todo_agent-0.2.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+todo_agent-0.2.8.dist-info/METADATA,sha256=ynVrlFUs89Qfgp6R3YnbvZGykjHD4CjNnJaLNm-oz1w,10047
+todo_agent-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+todo_agent-0.2.8.dist-info/entry_points.txt,sha256=4W7LrCib6AXP5IZDwWRht8S5gutLu5oNfTJHGbt4oHs,52
+todo_agent-0.2.8.dist-info/top_level.txt,sha256=a65mlPIhPZHuq2bRIi_sCMAIJsUddvXt171OBF6r6co,11
+todo_agent-0.2.8.dist-info/RECORD,,

todo_agent-0.2.6.dist-info/RECORD

@@ -1,29 +0,0 @@
-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,,