minion-code 0.1.0__py3-none-any.whl

examples/file_freshness_example.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Example usage of the FileFreshnessService with event system."""
+
+import os
+import sys
+import time
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from minion_code.services import (
+    file_freshness_service,
+    add_event_listener,
+    emit_event,
+    record_file_read,
+    record_file_edit,
+    check_file_freshness,
+)
+
+
+def main():
+    """Demonstrate FileFreshnessService usage."""
+    
+    # Create a test file
+    test_file = "test_file.txt"
+    with open(test_file, "w") as f:
+        f.write("Initial content")
+    
+    print("=== File Freshness Service Demo ===\n")
+    
+    # Set up event listeners to monitor what's happening
+    def on_file_read(context):
+        print(f"📖 File read event: {context.data['file_path']}")
+    
+    def on_file_edited(context):
+        print(f"✏️  File edited event: {context.data['file_path']}")
+    
+    def on_file_conflict(context):
+        print(f"⚠️  File conflict detected: {context.data['file_path']}")
+    
+    add_event_listener('file:read', on_file_read)
+    add_event_listener('file:edited', on_file_edited)
+    add_event_listener('file:conflict', on_file_conflict)
+    
+    # 1. Record initial file read
+    print("1. Recording initial file read...")
+    record_file_read(test_file)
+    
+    # 2. Check freshness (should be fresh)
+    print("\n2. Checking file freshness...")
+    result = check_file_freshness(test_file)
+    print(f"   Is fresh: {result.is_fresh}, Conflict: {result.conflict}")
+    
+    # 3. Simulate external modification
+    print("\n3. Simulating external file modification...")
+    time.sleep(0.1)  # Small delay to ensure different timestamp
+    with open(test_file, "w") as f:
+        f.write("Modified content externally")
+    
+    # 4. Check freshness again (should detect conflict)
+    print("\n4. Checking freshness after external modification...")
+    result = check_file_freshness(test_file)
+    print(f"   Is fresh: {result.is_fresh}, Conflict: {result.conflict}")
+    
+    # 5. Record agent edit (should clear conflict)
+    print("\n5. Recording agent edit...")
+    record_file_edit(test_file, "Agent modified content")
+    
+    # 6. Check freshness after agent edit
+    print("\n6. Checking freshness after agent edit...")
+    result = check_file_freshness(test_file)
+    print(f"   Is fresh: {result.is_fresh}, Conflict: {result.conflict}")
+    
+    # 7. Show session files and conflicts
+    print("\n7. Session summary:")
+    session_files = file_freshness_service.get_session_files()
+    conflicted_files = file_freshness_service.get_conflicted_files()
+    important_files = file_freshness_service.get_important_files()
+    
+    print(f"   Session files: {session_files}")
+    print(f"   Conflicted files: {conflicted_files}")
+    print(f"   Important files: {important_files}")
+    
+    # 8. Test session reset
+    print("\n8. Resetting session...")
+    emit_event('session:startup', {'context': {}})
+    
+    session_files_after = file_freshness_service.get_session_files()
+    print(f"   Session files after reset: {session_files_after}")
+    
+    # Cleanup
+    os.remove(test_file)
+    print("\n✅ Demo completed successfully!")
+
+
+if __name__ == "__main__":
+    main()

examples/file_watching_example.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Example usage of file watching functionality."""
+
+import os
+import sys
+import time
+import threading
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from minion_code.services import (
+    start_watching_todo_file,
+    stop_watching_todo_file,
+    add_event_listener,
+    record_file_read,
+    file_freshness_service,
+)
+
+
+def main():
+    """Demonstrate file watching functionality."""
+    
+    print("=== File Watching Demo ===\n")
+    
+    # Set up event listeners
+    def on_todo_file_changed(context):
+        data = context.data
+        print(f"🔔 Todo file changed for agent {data['agent_id']}")
+        print(f"   File: {data['file_path']}")
+        print(f"   Reminder: {data['reminder']}")
+        print()
+    
+    add_event_listener('todo:file_changed', on_todo_file_changed)
+    
+    # Create test directory and file
+    test_dir = "test_todos"
+    os.makedirs(test_dir, exist_ok=True)
+    
+    test_file = os.path.join(test_dir, "agent1.json")
+    agent_id = "agent1"
+    
+    # Create initial todo file
+    with open(test_file, "w") as f:
+        f.write('{"todos": [{"id": 1, "content": "Initial task", "status": "pending"}]}')
+    
+    print(f"1. Created test todo file: {test_file}")
+    
+    # Start watching the file
+    print(f"2. Starting to watch todo file for agent: {agent_id}")
+    start_watching_todo_file(agent_id, test_file)
+    
+    # Record initial read
+    record_file_read(test_file)
+    print("3. Recorded initial file read")
+    
+    # Check if we're watching
+    watched_files = file_freshness_service.get_watched_files()
+    print(f"4. Currently watching files: {watched_files}")
+    
+    # Wait a bit for watcher to initialize
+    time.sleep(1)
+    
+    # Simulate external modification
+    print("\n5. Simulating external file modification...")
+    
+    def modify_file():
+        time.sleep(0.5)  # Small delay
+        with open(test_file, "w") as f:
+            f.write('{"todos": [{"id": 1, "content": "Modified task", "status": "completed"}]}')
+        print("   ✏️  File modified externally")
+    
+    # Run modification in separate thread to avoid blocking
+    modifier_thread = threading.Thread(target=modify_file)
+    modifier_thread.start()
+    
+    # Wait for modification and watcher to detect it
+    modifier_thread.join()
+    time.sleep(2)  # Give watcher time to detect change
+    
+    # Modify file again
+    print("6. Another external modification...")
+    time.sleep(0.5)
+    with open(test_file, "w") as f:
+        f.write('{"todos": [{"id": 2, "content": "Another task", "status": "pending"}]}')
+    
+    # Wait for detection
+    time.sleep(2)
+    
+    # Stop watching
+    print("7. Stopping file watcher...")
+    stop_watching_todo_file(agent_id)
+    
+    # Verify we're no longer watching
+    watched_files_after = file_freshness_service.get_watched_files()
+    print(f"8. Files being watched after stop: {watched_files_after}")
+    
+    # Cleanup
+    try:
+        os.remove(test_file)
+        os.rmdir(test_dir)
+        print("\n🧹 Cleaned up test files")
+    except Exception as e:
+        print(f"⚠️  Cleanup warning: {e}")
+    
+    print("\n✅ File watching demo completed!")
+
+
+if __name__ == "__main__":
+    main()

examples/interruptible_tui.py

@@ -0,0 +1,5 @@
+from minion_code.cli import app
+def run():
+    app()
+if __name__ == '__main__':
+    app()

examples/message_response_children_demo.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Demo showing MessageResponse with children usage
+Equivalent to React's <MessageResponse><Message /></MessageResponse> pattern
+"""
+
+import asyncio
+import time
+from textual.app import App, ComposeResult
+from textual.containers import Container, Vertical, ScrollableContainer
+from textual.widgets import Header, Footer, Button, Static
+
+# Import the components
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from minion_code.components import Message, MessageResponse
+from minion_code.types import Message as MessageType, MessageContent, MessageType as MsgType
+
+
+class MessageResponseChildrenDemo(App):
+    """Demo showing MessageResponse children usage like React"""
+    
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    
+    .demo-container {
+        padding: 1;
+        height: 100%;
+    }
+    
+    .messages-container {
+        height: 1fr;
+        border: solid $primary;
+        padding: 1;
+        margin-bottom: 1;
+    }
+    
+    .controls {
+        height: auto;
+        dock: bottom;
+        padding: 1;
+        background: $surface-lighten-1;
+    }
+    """
+    
+    def compose(self) -> ComposeResult:
+        """Compose the demo interface"""
+        yield Header()
+        
+        with Container(classes="demo-container"):
+            with ScrollableContainer(classes="messages-container", id="messages"):
+                # Show examples of different usage patterns
+                yield from self._create_usage_examples()
+            
+            # with Container(classes="controls"):
+            #     yield Button("Add Tool Progress", id="add_tool_progress", variant="primary")
+            #     yield Button("Add Nested Response", id="add_nested", variant="success")
+            #     yield Button("Add Multiple Children", id="add_multiple", variant="warning")
+            #     yield Button("Add Dynamic Mount", id="add_dynamic", variant="default")
+            #     yield Button("Clear", id="clear", variant="error")
+        
+        yield Footer()
+        self.log(self.tree)
+    
+    def _create_usage_examples(self):
+        """Create examples showing different MessageResponse usage patterns"""
+        child_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("This message is wrapped in MessageResponse"),
+            timestamp=time.time()
+        )
+        yield Message(child_msg, classes="example-header")
+        yield Static("\n2. Single child message (React-like):", classes="example-header")
+
+        # This is equivalent to: <MessageResponse><Message /></MessageResponse>
+
+        yield MessageResponse(children=[Message(child_msg, classes="example-header")])
+        
+        # Example 3: Tool execution progress
+        yield Static("\n3. Tool execution progress:", classes="example-header")
+        tool_msg = MessageType(
+            type=MsgType.TOOL_USE,
+            message=MessageContent([{
+                "type": "tool_use",
+                "id": "tool_demo",
+                "name": "file_editor",
+                "input": {"path": "demo.py", "content": "print('Hello')"}
+            }]),
+            timestamp=time.time()
+        )
+        yield MessageResponse(children=[Message(tool_msg, verbose=True)])
+        
+        # Example 4: Multiple children (using initialization)
+        yield Static("\n4. Multiple children:", classes="example-header")
+        
+        # Add multiple children to demonstrate flexibility
+        status_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("Step 1: Analyzing code..."),
+            timestamp=time.time()
+        )
+        progress_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("Step 2: Applying changes..."),
+            timestamp=time.time()
+        )
+        
+        # Create with children during initialization
+        yield MessageResponse(children=[
+            Message(status_msg),
+            Message(progress_msg)
+        ])
+    
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses"""
+        messages_container = self.query_one("#messages", ScrollableContainer)
+        
+        if event.button.id == "add_tool_progress":
+            self._add_tool_progress(messages_container)
+        elif event.button.id == "add_nested":
+            self._add_nested_response(messages_container)
+        elif event.button.id == "add_multiple":
+            self._add_multiple_children(messages_container)
+        elif event.button.id == "add_dynamic":
+            self._add_dynamic_mount(messages_container)
+        elif event.button.id == "clear":
+            self._clear_messages(messages_container)
+    
+    def _add_tool_progress(self, container):
+        """Add tool execution progress using MessageResponse + Message"""
+        # Simulate tool execution progress
+        tool_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("🔧 Executing file operation..."),
+            timestamp=time.time()
+        )
+        
+        # Create MessageResponse with child during initialization
+        response = MessageResponse(children=[Message(tool_msg)])
+        
+        container.mount(response)
+        container.scroll_end()
+    
+    def _add_nested_response(self, container):
+        """Add nested MessageResponse (response within response)"""
+        # Create outer message
+        outer_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("Starting complex operation..."),
+            timestamp=time.time()
+        )
+        
+        # Create inner message for sub-operation
+        inner_msg = MessageType(
+            type=MsgType.ASSISTANT,
+            message=MessageContent("  └─ Sub-operation in progress..."),
+            timestamp=time.time()
+        )
+        
+        # Create nested structure with initialization
+        inner_response = MessageResponse(children=[Message(inner_msg)])
+        outer_response = MessageResponse(children=[
+            Message(outer_msg),
+            inner_response
+        ])
+        
+        container.mount(outer_response)
+        container.scroll_end()
+    
+    def _add_multiple_children(self, container):
+        """Add MessageResponse with multiple child messages"""
+        # Create multiple related messages
+        messages = [
+            MessageType(
+                type=MsgType.ASSISTANT,
+                message=MessageContent(f"Processing step {i+1}/3..."),
+                timestamp=time.time()
+            ) for i in range(3)
+        ]
+        
+        # Create MessageResponse with multiple children during initialization
+        message_widgets = [Message(msg) for msg in messages]
+        response = MessageResponse(children=message_widgets)
+        
+        container.mount(response)
+        container.scroll_end()
+    
+    def _add_dynamic_mount(self, container):
+        """Add MessageResponse and then dynamically mount children after it's mounted"""
+        # Create empty MessageResponse first
+        response = MessageResponse(content="Dynamic mounting example:")
+        
+        # Mount it to the container
+        container.mount(response)
+        
+        # Use call_after_refresh to mount children after the component is fully mounted
+        def mount_children_after():
+            msg = MessageType(
+                type=MsgType.ASSISTANT,
+                message=MessageContent("This was added dynamically after mounting!"),
+                timestamp=time.time()
+            )
+            response.mount_child(Message(msg))
+        
+        # Schedule the dynamic mounting
+        self.call_after_refresh(mount_children_after)
+        container.scroll_end()
+    
+    def _clear_messages(self, container):
+        """Clear all messages except headers"""
+        for child in list(container.children)[2:]:  # Keep title and subtitle
+            child.remove()
+
+
+def main():
+    """Run the demo application"""
+    app = MessageResponseChildrenDemo()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

examples/rich_example.py

@@ -0,0 +1,4 @@
+from rich.console import Console
+
+console = Console()
+console.prompt("Enter your name: ")  # This doesn't exist in rich

examples/simple_file_watching.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Simple file watching example."""
+
+import os
+import sys
+import time
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from minion_code.services import (
+    start_watching_todo_file,
+    stop_watching_todo_file,
+    add_event_listener,
+    record_file_read,
+)
+
+
+def main():
+    """Simple file watching demonstration."""
+    
+    # Set up event listener
+    def on_file_changed(context):
+        print(f"📁 File changed: {context.data['file_path']}")
+        print(f"💡 {context.data['reminder']}")
+    
+    add_event_listener('todo:file_changed', on_file_changed)
+    
+    # Create test file
+    test_file = "simple_todo.json"
+    with open(test_file, "w") as f:
+        f.write('{"task": "initial"}')
+    
+    print(f"✅ Created {test_file}")
+    
+    # Start watching
+    start_watching_todo_file("test_agent", test_file)
+    record_file_read(test_file)
+    print("👀 Started watching file")
+    
+    # Wait and modify
+    time.sleep(1)
+    print("✏️  Modifying file...")
+    with open(test_file, "w") as f:
+        f.write('{"task": "modified"}')
+    
+    # Wait for detection
+    time.sleep(2)
+    
+    # Stop watching and cleanup
+    stop_watching_todo_file("test_agent")
+    os.remove(test_file)
+    print("🧹 Cleaned up")
+
+
+if __name__ == "__main__":
+    main()