cognautic-cli 1.1.3__tar.gz → 1.1.4__tar.gz

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: cognautic-cli
-Version: 1.1.3
+Version: 1.1.4
 Summary: A Python-based CLI AI coding agent that provides agentic development capabilities with multi-provider AI support and real-time interaction
 Home-page: https://github.com/cognautic/cognautic-cli
 Author: Cognautic
 Author-email: Cognautic <cognautic@gmail.com>
 Maintainer-email: Cognautic <cognautic@gmail.com>
-License: Proprietary - All Rights Reserved
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/cognautic/cli
 Project-URL: Documentation, https://cognautic.vercel.app/cognautic-cli.html
 Project-URL: Repository, https://github.com/cognautic/cli.git

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/cognautic/__init__.py

@@ -2,6 +2,6 @@
 Cognautic CLI - A Python-based CLI AI coding agent
 """
 
-__version__ = "1.1.3"
+__version__ = "1.1.4"
 __author__ = "Cognautic"
 __email__ = "cognautic@gmail.com"

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/cognautic/ai_engine.py

@@ -960,7 +960,7 @@ class AIEngine:
                 return
 
             # Only continue if the auto-continuation manager says so
-            if self.auto_continuation.should_continue(tool_results, has_end_response):
+            if self.auto_continuation.should_continue(tool_results, has_end_response, buffer):
                 yield "... \n"
 
                 # Add assistant's response to messages
@@ -968,7 +968,7 @@ class AIEngine:
 
                 # Build continuation prompt
                 continuation_prompt = self.auto_continuation.build_continuation_prompt(
-                    tool_results
+                    tool_results, buffer
                 )
 
                 # Add continuation prompt to messages
@@ -2255,6 +2255,79 @@ For web search:
 }
 ```
 
+For directory context and project structure:
+
+```json
+{
+  "tool_code": "directory_context",
+  "args": {
+    "operation": "get_directory_summary"
+  }
+}
+```
+
+```json
+{
+  "tool_code": "directory_context",
+  "args": {
+    "operation": "list_directory_tree",
+    "max_depth": 3
+  }
+}
+```
+
+```json
+{
+  "tool_code": "directory_context",
+  "args": {
+    "operation": "get_project_structure"
+  }
+}
+```
+
+For code navigation (jump to definition, find references, search symbols):
+
+```json
+{
+  "tool_code": "code_navigation",
+  "args": {
+    "operation": "jump_to_definition",
+    "symbol": "MyClass"
+  }
+}
+```
+
+```json
+{
+  "tool_code": "code_navigation",
+  "args": {
+    "operation": "find_references",
+    "symbol": "myFunction"
+  }
+}
+```
+
+```json
+{
+  "tool_code": "code_navigation",
+  "args": {
+    "operation": "search_symbols",
+    "query": "handler",
+    "symbol_type": "function"
+  }
+}
+```
+
+```json
+{
+  "tool_code": "code_navigation",
+  "args": {
+    "operation": "list_symbols",
+    "file_path": "src/main.py"
+  }
+}
+```
+
 EXAMPLE WORKFLOWS:
 
 When user asks to ADD FEATURE to existing project (e.g., "add export button to cymox"):
@@ -2308,10 +2381,14 @@ Available tools:
 - command_runner: Execute shell commands (use run_async_command for long tasks)
 - web_search: Search the web for information
 - response_control: Use end_response when task is complete
+- directory_context: Get detailed directory structure and project information
+- code_navigation: Jump to definition, find references, search symbols in code
+
+RESPONSE CONTINUATION (CRITICAL - SYSTEM WILL AUTO-CONTINUE):
+- ⚠️ IMPORTANT: The system will AUTOMATICALLY continue your response after EVERY message
+- This means you will KEEP GETTING called until you explicitly call end_response
+- YOU MUST call end_response when you finish ALL work, or you'll loop forever:
 
-RESPONSE CONTINUATION (CRITICAL - ALWAYS USE end_response):
-- By default, after executing tools, the AI will automatically continue to complete the task
-- YOU MUST ALWAYS use the response_control tool when you finish ALL work:
 ```json
 {
   "tool_code": "response_control",
@@ -2320,16 +2397,21 @@ RESPONSE CONTINUATION (CRITICAL - ALWAYS USE end_response):
   }
 }
 ```
-- WHEN TO USE end_response (ALWAYS use it in these cases):
-  * After creating/modifying ALL requested files
-  * After completing ALL steps of a multi-step task
-  * After providing final explanation or summary
-  * Basically: ALWAYS use it when you're done with everything
-- Do NOT use end_response ONLY if:
-  * The task is incomplete
-  * You're waiting for user input
-  * You need to execute more tools
-- IMPORTANT: Forgetting to use end_response causes the user to manually type "continue" - ALWAYS use it!
+
+- HOW IT WORKS:
+  * You respond → System auto-continues → You respond again → System auto-continues → ...
+  * This loop ONLY stops when you call end_response
+  * If you say "I will use a tool" but don't execute it, system will auto-continue and remind you
+  * If you execute tools, system will auto-continue for next steps
+  * If you do nothing, system will still auto-continue
+
+- WHEN TO USE end_response (THE ONLY WAY TO STOP):
+  * ✅ After completing ALL requested work
+  * ✅ After providing final summary/instructions
+  * ✅ When task is 100% complete
+  * ❌ NEVER use it if task is incomplete - system will continue for you
+
+- CRITICAL: If you forget end_response, you'll keep getting called in an infinite loop!
 
 REMEMBER:
 1. Use tools to actually perform actions, don't just provide code examples!
@@ -2459,6 +2541,70 @@ When creating or modifying files:
         if project_path:
             prompt += f"\n\nCurrent project path: {project_path}"
             prompt += "\nYou can analyze and modify files in this project."
+            
+            # Add directory context automatically
+            try:
+                from pathlib import Path
+                project_dir = Path(project_path)
+                if project_dir.exists() and project_dir.is_dir():
+                    prompt += "\n\n" + "=" * 80
+                    prompt += "\n📁 CURRENT DIRECTORY CONTENTS (AUTO-PROVIDED FOR CONTEXT)"
+                    prompt += "\n" + "=" * 80
+                    
+                    # List immediate directory contents
+                    contents = []
+                    files = []
+                    dirs = []
+                    
+                    try:
+                        for item in sorted(project_dir.iterdir()):
+                            if item.name.startswith('.') and item.name not in ['.gitignore', '.env.example']:
+                                continue  # Skip hidden files except important ones
+                            
+                            if item.is_dir():
+                                # Count items in directory
+                                try:
+                                    item_count = len(list(item.iterdir()))
+                                    dirs.append(f"  📂 {item.name}/ ({item_count} items)")
+                                except (PermissionError, OSError):
+                                    dirs.append(f"  📂 {item.name}/")
+                            else:
+                                # Get file size
+                                try:
+                                    size = item.stat().st_size
+                                    if size < 1024:
+                                        size_str = f"{size}B"
+                                    elif size < 1024 * 1024:
+                                        size_str = f"{size/1024:.1f}KB"
+                                    else:
+                                        size_str = f"{size/(1024*1024):.1f}MB"
+                                    files.append(f"  📄 {item.name} ({size_str})")
+                                except (PermissionError, OSError):
+                                    files.append(f"  📄 {item.name}")
+                        
+                        prompt += f"\n\nDirectory: {project_path}"
+                        prompt += f"\n\nDirectories ({len(dirs)}):"
+                        if dirs:
+                            prompt += "\n" + "\n".join(dirs)
+                        else:
+                            prompt += "\n  (none)"
+                        
+                        prompt += f"\n\nFiles ({len(files)}):"
+                        if files:
+                            prompt += "\n" + "\n".join(files)
+                        else:
+                            prompt += "\n  (none)"
+                        
+                        prompt += "\n\n" + "=" * 80
+                        prompt += "\nℹ️  This directory listing is provided automatically for your context."
+                        prompt += "\nℹ️  You can use the 'directory_context' tool for more detailed information."
+                        prompt += "\n" + "=" * 80
+                        
+                    except PermissionError:
+                        prompt += "\n\n⚠️  Permission denied accessing directory contents."
+            except Exception:
+                # Silently fail if directory context can't be added
+                pass
 
         return prompt
 

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/cognautic/auto_continuation.py

@@ -26,129 +26,124 @@ class AutoContinuationManager:
         self.iteration_count = 0
         self.previous_tool_types = []
     
-    def should_continue(self, tool_results: List[Dict[str, Any]], has_end_response: bool) -> bool:
+    def should_continue(
+        self, 
+        tool_results: List[Dict[str, Any]], 
+        has_end_response: bool,
+        ai_response: str = ""
+    ) -> bool:
         """
         Determine if AI should automatically continue
         
+        SIMPLIFIED LOGIC: Always continue EXCEPT when end_response is called
+        This ensures AI completes tasks without manual intervention
+        
         Args:
             tool_results: List of tool execution results
             has_end_response: Whether end_response tool was called
+            ai_response: The AI's text response (to detect promises without execution)
             
         Returns:
             True if should continue, False otherwise
         """
-        # Don't continue if end_response was explicitly called
+        # RULE 1: Don't continue if end_response was explicitly called
+        # This is the ONLY condition that stops auto-continuation
         if has_end_response:
             return False
         
-        # Don't continue if max iterations reached
+        # RULE 2: Don't continue if max iterations reached (safety limit)
         if self.iteration_count >= self.max_iterations:
             return False
         
-        # Don't continue if no tools were executed
-        if not tool_results:
-            return False
-        
-        # Check if there were any errors
-        has_errors = any(r.get('type') == 'error' for r in tool_results)
-        
-        # Check what types of tools were executed
-        has_file_ops = any(r.get('type') in ['file_op', 'file_write'] for r in tool_results)  # Exclude file_read from has_file_ops
-        has_file_read = any(r.get('type') in ['file_read', 'file_reader'] for r in tool_results)  # Include both file reading types
-        has_commands = any(r.get('type') == 'command' for r in tool_results)
-        has_background_commands = any(
-            r.get('type') == 'command' and 'background' in str(r.get('command', ''))
-            for r in tool_results
-        )
-        
-        # Check for web searches (which might indicate looking for information before proceeding)
-        has_web_search = any(r.get('type') in ['web_search', 'web_fetch'] for r in tool_results)
-        
-        # Check if commands were exploratory (ls, pwd, dir, etc.)
-        exploratory_commands = ['ls', 'pwd', 'dir', 'cd', 'find', 'tree', 'cat', 'head', 'tail']
-        has_exploratory_commands = any(
-            r.get('type') == 'command' and 
-            any(cmd in str(r.get('command', '')).lower() for cmd in exploratory_commands)
-            for r in tool_results
-        )
-        
-        # Track current tool types for repetition detection
-        current_tool_types = []
-        for result in tool_results:
-            tool_type = result.get('type', 'unknown')
-            current_tool_types.append(tool_type)
-        
-        # Check for repeated operations of the same type (especially web searches)
-        is_repeating_search = (
-            has_web_search and 
-            self.previous_tool_types and 
-            all('web_search' in prev_type or 'web_fetch' in prev_type for prev_type in self.previous_tool_types[-3:])
-        )
-        
-        # Store current types for next check (keep last 5 to detect patterns)
-        self.previous_tool_types.extend(current_tool_types)
-        self.previous_tool_types = self.previous_tool_types[-5:]  # Keep only last 5
-        
-        # Smart continuation logic:
-        # 1. If there are errors, continue to let AI handle them
-        if has_errors:
-            self.iteration_count += 1
-            return True
-
-        # 2. If file was read, always continue so AI can act on the content
-        if has_file_read:
-            self.iteration_count += 1
-            return True
-        
-        # 3. If repeating the same operation (like web searches), don't continue to break the loop
-        if is_repeating_search and self.iteration_count > 3:
-            return False  # Break the loop if repeating searches for more than 3 iterations
-        
-        # 4. If only file operations were done, likely need to run commands next
-        if has_file_ops and not has_commands:
-            self.iteration_count += 1
-            return True
-        
-        # 5. If only exploratory commands (ls, pwd, etc.), continue to do actual work
-        if has_exploratory_commands and not (has_file_ops or has_file_read):
-            self.iteration_count += 1
-            return True
-        
-        # 6. If web search was performed, often AI should continue to create files/execute commands with the information
-        if has_web_search and not has_file_ops:
-            self.iteration_count += 1
-            return True
-        
-        # 7. If background commands were started AND files created, task likely complete
-        if has_background_commands and (has_file_ops or has_file_read):
-            return False
-        
-        # 8. If only background commands (no files), don't continue (they're running)
-        if has_background_commands and not (has_file_ops or has_file_read):
-            return False
-        
-        # 9. If regular commands executed with file ops, task likely complete
-        if has_commands and has_file_ops and not has_exploratory_commands:
-            return False
+        # RULE 3: Check if AI said it would use tools but didn't execute them
+        # This handles the scenario where AI says "I will use X tool" but doesn't
+        if not tool_results and ai_response:
+            promise_indicators = [
+                "i will use",
+                "i can use",
+                "let me use",
+                "i'll use",
+                "using the",
+                "i will call",
+                "i'll call",
+                "let me call",
+                "i can help you with that",
+                "i will list",
+                "i will find",
+                "i will search",
+                "i will check",
+                "i will analyze",
+                "i will show",
+                "i will count"
+            ]
+            
+            ai_lower = ai_response.lower()
+            
+            # Check if AI promised to use tools
+            promised_to_use_tools = any(indicator in ai_lower for indicator in promise_indicators)
+            
+            # Check if AI mentioned specific tools
+            tool_mentions = [
+                "code_navigation",
+                "directory_context",
+                "file_operations",
+                "web_search",
+                "command_runner",
+                "tool"
+            ]
+            mentioned_tools = any(tool in ai_lower for tool in tool_mentions)
+            
+            # If AI promised to use tools or mentioned specific tools but didn't execute any
+            if promised_to_use_tools or mentioned_tools:
+                self.iteration_count += 1
+                return True
         
-        # 10. Default: Continue if we're early in the process
-        # This ensures AI completes the full task
-        if self.iteration_count < 3:
+        # RULE 4: If no tools were executed and no promises detected, still continue
+        # The AI might need another chance to complete the task
+        if not tool_results:
             self.iteration_count += 1
             return True
         
-        return False
+        # RULE 5: If ANY tools were executed, ALWAYS continue
+        # Let the AI decide when it's done by calling end_response
+        self.iteration_count += 1
+        return True
     
-    def build_continuation_prompt(self, tool_results: List[Dict[str, Any]]) -> str:
+    def build_continuation_prompt(
+        self, 
+        tool_results: List[Dict[str, Any]],
+        ai_response: str = ""
+    ) -> str:
         """
         Build an appropriate continuation prompt based on tool results
         
         Args:
             tool_results: List of tool execution results
+            ai_response: The AI's text response (to provide context)
             
         Returns:
             Continuation prompt string
         """
+        # Special case: AI said it would use tools but didn't
+        if not tool_results and ai_response:
+            return """You said you would use a tool, but you didn't actually execute it.
+
+CRITICAL: You MUST include the actual JSON tool call in your response, not just say you will do it.
+
+For example, if you want to use code_navigation to list symbols, you MUST include:
+
+```json
+{
+  "tool_code": "code_navigation",
+  "args": {
+    "operation": "list_symbols",
+    "file_path": "main.py"
+  }
+}
+```
+
+Now execute the tool you mentioned:"""
+        
         # Categorize tool results
         has_file_ops = any(r.get('type') in ['file_op', 'file_write', 'file_read'] for r in tool_results)
         has_commands = any(r.get('type') == 'command' for r in tool_results)

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/cognautic/cli.py

@@ -75,19 +75,8 @@ from .rules import RulesManager
 
 console = Console()
 
-# Global flag to stop AI response
-stop_response = False
-
-def signal_handler(signum, frame):
-    """Handle Ctrl+X (SIGQUIT) to stop AI response"""
-    global stop_response
-    stop_response = True
-
-
-
-
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.1.3", prog_name="Cognautic CLI")
+@click.version_option(version="1.1.4", prog_name="Cognautic CLI")
 @click.pass_context
 def main(ctx):
     """Cognautic CLI - AI-powered development assistant"""
@@ -187,16 +176,16 @@ def chat(provider, model, project_path, websocket_port, session):
     websocket_server = WebSocketServer(ai_engine, port=websocket_port)
     
     async def run_chat():
-        global stop_response
-        
-        # Set up Ctrl+X signal handler (SIGQUIT)
-        signal.signal(signal.SIGQUIT, signal_handler)
-        
         # Start WebSocket server
         server_task = asyncio.create_task(websocket_server.start())
         
+        # Track last Ctrl+C time for double-tap detection
+        import time
+        last_ctrl_c_time = [0]  # Use list to make it mutable in nested function
+        
         try:
-            console.print("INFO: Type '/help' for commands, 'exit' to quit")
+            console.print("INFO: Type '/help' for commands, or press Ctrl+C twice to exit")
+            console.print("INFO: Press Enter to send, Alt+Enter for new line")
             console.print("INFO: Press Shift+Tab to toggle Terminal mode")
             if project_path:
                 console.print(f"DIR: Working in: {project_path}")
@@ -246,7 +235,7 @@ def chat(provider, model, project_path, websocket_port, session):
             # Terminal mode state
             terminal_mode = [False]  # Use list to make it mutable in nested function
             
-            # Setup key bindings for Shift+Tab toggle
+            # Setup key bindings for Shift+Tab toggle and multi-line support
             bindings = KeyBindings()
             
             @bindings.add('s-tab')  # Shift+Tab
@@ -257,8 +246,19 @@ def chat(provider, model, project_path, websocket_port, session):
                 event.app.current_buffer.text = ''
                 event.app.exit(result='__MODE_TOGGLE__')
             
-            # Create prompt session
-            session = PromptSession(key_bindings=bindings)
+            @bindings.add('enter')  # Enter key submits
+            def submit_message(event):
+                event.current_buffer.validate_and_handle()
+            
+            @bindings.add('escape', 'enter')  # Meta+Enter (Alt+Enter) adds new line
+            def new_line(event):
+                event.current_buffer.insert_text('\n')
+            
+            # Create prompt session with multi-line support
+            session = PromptSession(
+                key_bindings=bindings,
+                multiline=True  # Allow multi-line editing
+            )
             
             console.print("[dim]INFO: Press Shift+Tab to toggle between Chat and Terminal modes[/dim]\n")
             
@@ -339,7 +339,7 @@ def chat(provider, model, project_path, websocket_port, session):
                                     console.print(f"[yellow]Exit code: {returncode}[/yellow]")
                                     
                             except KeyboardInterrupt:
-                                # Handle Ctrl+C - terminate the process
+                                # Handle Ctrl+C - terminate the process but don't exit CLI
                                 console.print("\n[yellow]^C[/yellow]")
                                 process.terminate()
                                 try:
@@ -419,8 +419,10 @@ def chat(provider, model, project_path, websocket_port, session):
                     console.print("[bold magenta]─[/bold magenta]" * 50)
                     console.print("[bold magenta]AI:[/bold magenta] ", end="")
                     full_response = ""
-                    response_stopped = False
-                    stop_response = False  # Reset stop flag
+                    
+                    # Disable Ctrl+C during AI response
+                    import signal
+                    original_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
                     
                     try:
                         async for chunk in ai_engine.process_message_stream(
@@ -430,42 +432,36 @@ def chat(provider, model, project_path, websocket_port, session):
                             project_path=current_workspace,
                             conversation_history=conversation_history
                         ):
-                            # Check if stop was requested
-                            if stop_response:
-                                response_stopped = True
-                                console.print("\n\n[yellow]⏸️  AI response stopped by user (Ctrl+X)[/yellow]")
-                                break
-                            
                             # Display character by character for typewriter effect
                             for char in chunk:
-                                # Check stop flag during character display too
-                                if stop_response:
-                                    response_stopped = True
-                                    console.print("\n\n[yellow]⏸️  AI response stopped by user (Ctrl+X)[/yellow]")
-                                    break
                                 console.print(char, end="")
                                 full_response += char
                                 if typing_delay > 0:
                                     await asyncio.sleep(typing_delay)
-                            
-                            if response_stopped:
-                                break
-                    except KeyboardInterrupt:
-                        # Ctrl+C pressed - exit chat
-                        break
+                    finally:
+                        # Re-enable Ctrl+C after AI response
+                        signal.signal(signal.SIGINT, original_handler)
                     
                     console.print()  # New line after streaming
                     console.print("[bold magenta]─[/bold magenta]" * 50)  # Border after AI response
                     
-                    # Add AI response to memory (even if stopped)
+                    # Add AI response to memory
                     if full_response:
                         memory_manager.add_message("assistant", full_response)
                     
-                    # Don't break - continue to next prompt
-                    
                 except KeyboardInterrupt:
-                    # Ctrl+C pressed while waiting for user input - exit chat
-                    break
+                    # Ctrl+C pressed while waiting for user input
+                    current_time = time.time()
+                    time_since_last = current_time - last_ctrl_c_time[0]
+                    
+                    if time_since_last < 2.0:  # Double tap within 2 seconds
+                        console.print("\n[yellow]Exiting...[/yellow]")
+                        break
+                    else:
+                        # First Ctrl+C - show hint
+                        console.print("\n[dim]Press Ctrl+C again within 2 seconds to exit, or type 'exit'[/dim]")
+                        last_ctrl_c_time[0] = current_time
+                        continue
                 except Exception as e:
                     console.print(f"ERROR: {str(e)}", style="red")
         
@@ -1200,6 +1196,9 @@ def show_help():
     """Show help information"""
     help_text = Text()
     help_text.append("Available commands:\n", style="bold")
+    help_text.append("• Press Enter - Send message\n", style="bold green")
+    help_text.append("• Press Alt+Enter - New line (multi-line input)\n", style="bold green")
+    help_text.append("• Press Ctrl+C twice - Exit CLI\n", style="bold yellow")
     help_text.append("• Press Shift+Tab - Toggle between Chat and Terminal modes\n", style="bold yellow")
     help_text.append("• /help - Show this help message\n")
     help_text.append("• /workspace <path> or /ws <path> - Change working directory\n")

{cognautic_cli-1.1.3 → cognautic_cli-1.1.4}/cognautic/tools/__init__.py

@@ -8,6 +8,8 @@ from .command_runner import CommandRunnerTool
 from .web_search import WebSearchTool
 from .code_analysis import CodeAnalysisTool
 from .response_control import ResponseControlTool
+from .directory_context import DirectoryContextTool
+from .code_navigation import CodeNavigationTool
 
 __all__ = [
     'ToolRegistry',
@@ -15,5 +17,7 @@ __all__ = [
     'CommandRunnerTool',
     'WebSearchTool',
     'CodeAnalysisTool',
-    'ResponseControlTool'
+    'ResponseControlTool',
+    'DirectoryContextTool',
+    'CodeNavigationTool'
 ]