cognautic-cli 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

cognautic/__init__.py

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

cognautic/ai_engine.py

@@ -779,20 +779,274 @@ class AIEngine:
         if max_tokens == 0 or max_tokens == -1:
             max_tokens = None  # Treat 0 or -1 as unlimited
 
-        # Generate response and process with tools
-        response = await ai_provider.generate_response(
-            messages=messages,
-            model=model,
-            max_tokens=max_tokens or 16384,  # Use large default if None
-            temperature=config.get("temperature", 0.7),
-        )
-
-        # Process response with tools
-        async for chunk in self._process_response_with_tools(
-            response, project_path, messages, ai_provider, model, config
+        # Stream response with real-time tool detection and execution
+        async for chunk in self._stream_with_live_tools(
+            ai_provider, messages, model, max_tokens, config, project_path
         ):
             yield chunk
 
+    async def _stream_with_live_tools(
+        self,
+        ai_provider,
+        messages: list,
+        model: str,
+        max_tokens: int,
+        config: dict,
+        project_path: str,
+        recursion_depth: int = 0,
+    ):
+        """Stream AI response with real-time tool detection and execution"""
+        import re
+        import json
+        
+        # Prevent infinite recursion
+        MAX_RECURSION_DEPTH = 10
+        if recursion_depth >= MAX_RECURSION_DEPTH:
+            yield "\n⚠️ **Warning:** Maximum continuation depth reached.\n"
+            return
+        
+        # Buffer to accumulate streaming response
+        buffer = ""
+        yielded_length = 0
+        in_json_block = False
+        json_block_start = -1
+        has_executed_tools = False
+        tool_results = []
+        
+        # Check if provider supports streaming
+        if not hasattr(ai_provider, 'generate_response_stream'):
+            # Fall back to non-streaming
+            response = await ai_provider.generate_response(
+                messages=messages,
+                model=model,
+                max_tokens=max_tokens or 16384,
+                temperature=config.get("temperature", 0.7),
+            )
+            async for chunk in self._process_response_with_tools(
+                response, project_path, messages, ai_provider, model, config
+            ):
+                yield chunk
+            return
+        
+        # Stream the response
+        try:
+            async for chunk in ai_provider.generate_response_stream(
+                messages=messages,
+                model=model,
+                max_tokens=max_tokens or 16384,
+                temperature=config.get("temperature", 0.7),
+            ):
+                if not chunk:
+                    continue
+                
+                buffer += chunk
+                
+                # Check for JSON block markers
+                if not in_json_block:
+                    # Look for start of JSON block
+                    json_start_match = re.search(r'```json\s*\n', buffer[yielded_length:])
+                    if json_start_match:
+                        # Found start of JSON block
+                        in_json_block = True
+                        json_block_start = yielded_length + json_start_match.start()
+                        
+                        # Yield everything BEFORE the JSON block
+                        if json_block_start > yielded_length:
+                            text_to_yield = buffer[yielded_length:json_block_start]
+                            text_to_yield = self._clean_model_syntax(text_to_yield)
+                            if text_to_yield.strip():
+                                yield text_to_yield
+                        yielded_length = json_block_start
+                    else:
+                        # No JSON block yet, yield new content (keep small buffer)
+                        if len(buffer) > yielded_length + 10:
+                            text_to_yield = buffer[yielded_length:-10]
+                            text_to_yield = self._clean_model_syntax(text_to_yield)
+                            if text_to_yield:
+                                yield text_to_yield
+                            yielded_length = len(buffer) - 10
+                else:
+                    # Inside JSON block, look for the end
+                    json_end_match = re.search(r'\n```', buffer[json_block_start:])
+                    if json_end_match:
+                        # Found end of JSON block
+                        json_block_end = json_block_start + json_end_match.end()
+                        
+                        # Extract the complete JSON block
+                        json_block = buffer[json_block_start:json_block_end]
+                        
+                        # Parse and execute the tool call immediately
+                        json_pattern = r'```json\s*\n(.*?)\n```'
+                        match = re.search(json_pattern, json_block, re.DOTALL)
+                        if match:
+                            try:
+                                tool_call = json.loads(match.group(1).strip())
+                                
+                                # Execute tool and yield result immediately
+                                async for tool_result in self._execute_single_tool_live(
+                                    tool_call, project_path, tool_results
+                                ):
+                                    yield tool_result
+                                    
+                                has_executed_tools = True
+                                
+                            except json.JSONDecodeError as je:
+                                yield f"\n⚠️ **JSON Parse Warning:** {str(je)}\n"
+                        
+                        # Update state
+                        in_json_block = False
+                        yielded_length = json_block_end
+                        json_block_start = -1
+            
+            # Yield any remaining content
+            if yielded_length < len(buffer):
+                remaining = buffer[yielded_length:]
+                if not in_json_block:
+                    remaining = self._clean_model_syntax(remaining)
+                    if remaining.strip():
+                        yield remaining
+            
+            # Check if end_response was called
+            has_end_response = any(r.get("type") == "control" and r.get("message") == "end_response" for r in tool_results)
+            
+            # Don't auto-continue if:
+            # 1. end_response was explicitly called
+            # 2. No tools were executed
+            # 3. Max recursion depth reached
+            if has_end_response or not has_executed_tools or recursion_depth >= MAX_RECURSION_DEPTH:
+                return
+            
+            # Only continue if the auto-continuation manager says so
+            if self.auto_continuation.should_continue(tool_results, has_end_response):
+                yield "\n\n🔄 **Auto-continuing...**\n\n"
+                
+                # Add assistant's response to messages
+                messages.append({"role": "assistant", "content": buffer})
+                
+                # Generate continuation
+                final_response = await self.auto_continuation.generate_continuation(
+                    ai_provider=ai_provider,
+                    messages=messages,
+                    tool_results=tool_results,
+                    model=model,
+                    config=config
+                )
+                
+                # Recursively stream continuation
+                async for chunk in self._stream_with_live_tools(
+                    ai_provider, messages, model, max_tokens, config, project_path, recursion_depth + 1
+                ):
+                    yield chunk
+                    
+        except Exception as e:
+            import traceback
+            yield f"\n❌ **Streaming Error:** {str(e)}\n"
+            yield f"\n**Traceback:**\n{traceback.format_exc()}\n"
+
+    async def _execute_single_tool_live(self, tool_call: dict, project_path: str, tool_results: list):
+        """Execute a single tool call and yield the result immediately"""
+        try:
+            tool_name = tool_call.get("tool_code")
+            args = tool_call.get("args", {})
+
+            # Check for response control tool
+            if tool_name == "response_control":
+                operation = args.get("operation", "end_response")
+                if operation == "end_response":
+                    yield "\n✅ **Response Completed**\n"
+                    tool_results.append({"type": "control", "message": "end_response"})
+                return
+
+            # Execute the tool (reuse existing tool execution logic)
+            if tool_name == "command_runner":
+                cmd_args = args.copy()
+                if "operation" not in cmd_args:
+                    cmd_args["operation"] = "run_command"
+                if "cwd" not in cmd_args:
+                    cmd_args["cwd"] = project_path or "."
+
+                result = await self.tool_registry.execute_tool(
+                    "command_runner", user_id="ai_engine", **cmd_args
+                )
+                
+                if result.success:
+                    command = args.get("command", "unknown")
+                    operation = cmd_args.get("operation", "run_command")
+                    
+                    if operation == "run_async_command":
+                        process_id = result.data.get("process_id", "unknown")
+                        pid = result.data.get("pid", "unknown")
+                        yield f"\n✅ **Tool Used:** command_runner (background)\n⚡ **Command:** {command}\n🔄 **Status:** Running in background\n📋 **Process ID:** {process_id} (PID: {pid})\n💡 **Tip:** Use `/ct {process_id}` to terminate\n"
+                        tool_results.append({"type": "command", "command": command, "success": True})
+                    else:
+                        stdout = result.data.get("stdout", "") if isinstance(result.data, dict) else str(result.data)
+                        stderr = result.data.get("stderr", "") if isinstance(result.data, dict) else ""
+                        
+                        full_output = stdout
+                        if stderr and stderr.strip():
+                            full_output += f"\n[stderr]\n{stderr}"
+                        
+                        display_output = full_output
+                        if len(full_output) > 10000:
+                            display_output = full_output[:10000] + f"\n\n... [Output truncated]"
+                        
+                        yield f"\n✅ **Tool Used:** command_runner\n⚡ **Command:** {command}\n📄 **Output:**\n```\n{display_output}\n```\n"
+                        tool_results.append({"type": "command", "command": command, "output": full_output, "success": True})
+                else:
+                    yield f"\n❌ **Command Error:** {result.error}\n"
+                    tool_results.append({"type": "error", "error": result.error, "success": False})
+
+            elif tool_name == "file_operations":
+                file_path = args.get("file_path")
+                if file_path and project_path:
+                    from pathlib import Path
+                    path = Path(file_path)
+                    if not path.is_absolute():
+                        args["file_path"] = str(Path(project_path) / file_path)
+
+                result = await self.tool_registry.execute_tool(
+                    "file_operations", user_id="ai_engine", **args
+                )
+                
+                if result.success:
+                    operation = args.get("operation")
+                    file_path = args.get("file_path")
+                    yield f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}\n"
+                    tool_results.append({"type": "file_op", "operation": operation, "success": True})
+                else:
+                    yield f"\n❌ **File Error:** {result.error}\n"
+                    tool_results.append({"type": "error", "error": result.error, "success": False})
+
+            elif tool_name == "web_search":
+                result = await self.tool_registry.execute_tool(
+                    "web_search", user_id="ai_engine", **args
+                )
+                
+                if result.success:
+                    operation = args.get("operation", "search_web")
+                    yield f"\n✅ **Tool Used:** web_search ({operation})\n"
+                    tool_results.append({"type": "web_search", "operation": operation, "success": True})
+                else:
+                    yield f"\n❌ **Web Search Error:** {result.error}\n"
+                    tool_results.append({"type": "error", "error": result.error, "success": False})
+
+            elif tool_name == "file_reader":
+                result = await self.tool_registry.execute_tool(
+                    "file_reader", user_id="ai_engine", **args
+                )
+                
+                if result.success:
+                    operation = args.get("operation")
+                    yield f"\n✅ **Tool Used:** file_reader ({operation})\n"
+                    tool_results.append({"type": "file_read", "operation": operation, "success": True})
+                else:
+                    yield f"\n❌ **File Reader Error:** {result.error}\n"
+                    tool_results.append({"type": "error", "error": result.error, "success": False})
+
+        except Exception as e:
+            yield f"\n❌ **Tool Error:** {str(e)}\n"
+            tool_results.append({"type": "error", "error": str(e), "success": False})
+
     def _parse_alternative_tool_calls(self, response: str):
         """Parse tool calls from alternative formats (e.g., GPT-OSS with special tokens)"""
         import re
@@ -919,9 +1173,10 @@ class AIEngine:
             if text_before_tools:
                 yield text_before_tools + "\n"
 
-        # Process all tool calls first, collect results
+        # Process and execute tool calls LIVE - show results immediately
         tool_results = []
         should_end_response = False
+        has_executed_tools = False
 
         # Combine standard JSON matches and alternative format tool calls
         all_tool_calls = []
@@ -947,14 +1202,13 @@ class AIEngine:
                     operation = args.get("operation", "end_response")
                     if operation == "end_response":
                         should_end_response = True
-                        tool_results.append(
-                            {
-                                "type": "control",
-                                "display": f"\n✅ **Response Completed**\n",
-                            }
-                        )
+                        yield "\n✅ **Response Completed**\n"
+                        tool_results.append({"type": "control", "message": "end_response"})
                     continue
 
+                # Mark that we've executed tools
+                has_executed_tools = True
+
                 # Execute the tool
                 if tool_name == "command_runner":
                     cmd_args = args.copy()
@@ -968,38 +1222,56 @@ class AIEngine:
                     )
                     if result.success:
                         command = args.get("command", "unknown")
-                        stdout = (
-                            result.data.get("stdout", "")
-                            if isinstance(result.data, dict)
-                            else str(result.data)
-                        )
-                        stderr = result.data.get("stderr", "") if isinstance(result.data, dict) else ""
-                        
-                        # Combine stdout and stderr for full output
-                        full_output = stdout
-                        if stderr and stderr.strip():
-                            full_output += f"\n[stderr]\n{stderr}"
+                        operation = cmd_args.get("operation", "run_command")
                         
-                        # Truncate very long outputs for display (but keep full output in data)
-                        display_output = full_output
-                        if len(full_output) > 10000:
-                            display_output = full_output[:10000] + f"\n\n... [Output truncated - {len(full_output)} total characters]"
-                        
-                        tool_results.append(
-                            {
+                        # Check if this is an async command
+                        if operation == "run_async_command":
+                            # Background command - show process ID
+                            process_id = result.data.get("process_id", "unknown")
+                            pid = result.data.get("pid", "unknown")
+                            display_msg = f"\n✅ **Tool Used:** command_runner (background)\n⚡ **Command:** {command}\n🔄 **Status:** Running in background\n📋 **Process ID:** {process_id} (PID: {pid})\n💡 **Tip:** Use `/ct {process_id}` to terminate this process\n"
+                            yield display_msg
+                            tool_results.append({
+                                "type": "command",
+                                "command": command,
+                                "output": f"Background process started: {process_id}",
+                                "success": True
+                            })
+                        else:
+                            # Synchronous command - show output
+                            stdout = (
+                                result.data.get("stdout", "")
+                                if isinstance(result.data, dict)
+                                else str(result.data)
+                            )
+                            stderr = result.data.get("stderr", "") if isinstance(result.data, dict) else ""
+                            
+                            # Combine stdout and stderr for full output
+                            full_output = stdout
+                            if stderr and stderr.strip():
+                                full_output += f"\n[stderr]\n{stderr}"
+                            
+                            # Truncate very long outputs for display (but keep full output in data)
+                            display_output = full_output
+                            if len(full_output) > 10000:
+                                display_output = full_output[:10000] + f"\n\n... [Output truncated - {len(full_output)} total characters]"
+                            
+                            display_msg = f"\n✅ **Tool Used:** command_runner\n⚡ **Command:** {command}\n📄 **Output:**\n```\n{display_output}\n```\n"
+                            yield display_msg
+                            tool_results.append({
                                 "type": "command",
                                 "command": command,
                                 "output": full_output,
-                                "display": f"\n✅ **Tool Used:** command_runner\n⚡ **Command:** {command}\n📄 **Output:**\n```\n{display_output}\n```\n",
-                            }
-                        )
+                                "success": True
+                            })
                     else:
-                        tool_results.append(
-                            {
-                                "type": "error",
-                                "display": f"\n❌ **Command Error:** {result.error}\n",
-                            }
-                        )
+                        error_msg = f"\n❌ **Command Error:** {result.error}\n"
+                        yield error_msg
+                        tool_results.append({
+                            "type": "error",
+                            "error": result.error,
+                            "success": False
+                        })
 
                 elif tool_name == "file_operations":
                     # Prepend project_path to relative file paths
@@ -1042,14 +1314,14 @@ class AIEngine:
                                 total = result.data.get("total_lines", 0)
                                 line_info = f" (lines {start}-{end} of {total})"
 
-                            tool_results.append(
-                                {
-                                    "type": "file_read",
-                                    "file_path": file_path,
-                                    "content": content,  # Full content for AI processing
-                                    "display": f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}{line_info}\n📄 **Result:**\n```\n{display_content}\n```\n",
-                                }
-                            )
+                            display_msg = f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}{line_info}\n📄 **Result:**\n```\n{display_content}\n```\n"
+                            yield display_msg
+                            tool_results.append({
+                                "type": "file_read",
+                                "file_path": file_path,
+                                "content": content,
+                                "success": True
+                            })
                         elif operation == "write_file_lines":
                             # Show line range info for write_file_lines
                             line_info = ""
@@ -1058,26 +1330,17 @@ class AIEngine:
                                 end = result.data.get("end_line", 1)
                                 lines_written = result.data.get("lines_written", 0)
                                 line_info = f" (lines {start}-{end}, {lines_written} lines written)"
-                            tool_results.append(
-                                {
-                                    "type": "file_op",
-                                    "display": f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}{line_info}\n",
-                                }
-                            )
+                            display_msg = f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}{line_info}\n"
+                            yield display_msg
+                            tool_results.append({"type": "file_op", "operation": operation, "success": True})
                         else:
-                            tool_results.append(
-                                {
-                                    "type": "file_op",
-                                    "display": f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}\n",
-                                }
-                            )
+                            display_msg = f"\n✅ **Tool Used:** file_operations\n📄 **Operation:** {operation} on {file_path}\n"
+                            yield display_msg
+                            tool_results.append({"type": "file_op", "operation": operation, "success": True})
                     else:
-                        tool_results.append(
-                            {
-                                "type": "error",
-                                "display": f"\n❌ **File Error:** {result.error}\n",
-                            }
-                        )
+                        error_msg = f"\n❌ **File Error:** {result.error}\n"
+                        yield error_msg
+                        tool_results.append({"type": "error", "error": result.error, "success": False})
 
                 elif tool_name == "web_search":
                     operation = args.get("operation", "search_web")
@@ -1100,14 +1363,13 @@ class AIEngine:
                                 )
                                 result_text += f"   🔗 {item.get('url', 'No URL')}\n"
 
-                            tool_results.append(
-                                {
-                                    "type": "web_search",
-                                    "query": query,
-                                    "results": search_results,
-                                    "display": result_text,
-                                }
-                            )
+                            yield result_text
+                            tool_results.append({
+                                "type": "web_search",
+                                "query": query,
+                                "results": search_results,
+                                "success": True
+                            })
 
                         elif operation == "fetch_url_content":
                             url = args.get("url", "unknown")
@@ -1135,14 +1397,8 @@ class AIEngine:
                                 f"**Content:**\n```\n{display_content}\n```\n"
                             )
 
-                            tool_results.append(
-                                {
-                                    "type": "web_fetch",
-                                    "url": url,
-                                    "content": content,  # Full content for AI processing
-                                    "display": result_text,
-                                }
-                            )
+                            yield result_text
+                            tool_results.append({"type": "web_fetch", "url": url, "content": content, "success": True})
 
                         elif operation == "parse_documentation":
                             url = args.get("url", "unknown")
@@ -1162,14 +1418,8 @@ class AIEngine:
                                         f"\n• {section.get('title', 'Untitled')}\n"
                                     )
 
-                            tool_results.append(
-                                {
-                                    "type": "web_docs",
-                                    "url": url,
-                                    "doc_data": doc_data,
-                                    "display": result_text,
-                                }
-                            )
+                            yield result_text
+                            tool_results.append({"type": "web_docs", "url": url, "doc_data": doc_data, "success": True})
 
                         elif operation == "get_api_docs":
                             api_name = args.get("api_name", "unknown")
@@ -1187,53 +1437,35 @@ class AIEngine:
                                 result_text += f"📚 **API:** {api_name}\n"
                                 result_text += f"❌ {api_data.get('message', 'Documentation not found')}\n"
 
-                            tool_results.append(
-                                {
-                                    "type": "web_api_docs",
-                                    "api_name": api_name,
-                                    "api_data": api_data,
-                                    "display": result_text,
-                                }
-                            )
+                            yield result_text
+                            tool_results.append({"type": "web_api_docs", "api_name": api_name, "api_data": api_data, "success": True})
                         else:
-                            tool_results.append(
-                                {
-                                    "type": "web_search",
-                                    "display": f"\n✅ **Tool Used:** web_search ({operation})\n",
-                                }
-                            )
+                            display_msg = f"\n✅ **Tool Used:** web_search ({operation})\n"
+                            yield display_msg
+                            tool_results.append({"type": "web_search", "operation": operation, "success": True})
                     else:
-                        tool_results.append(
-                            {
-                                "type": "error",
-                                "display": f"\n❌ **Web Search Error:** {result.error}\n",
-                            }
-                        )
+                        error_msg = f"\n❌ **Web Search Error:** {result.error}\n"
+                        yield error_msg
+                        tool_results.append({"type": "error", "error": result.error, "success": False})
 
             except json.JSONDecodeError as e:
-                tool_results.append(
-                    {
-                        "type": "error",
-                        "display": f"\n❌ **JSON Parse Error:** {str(e)}\n",
-                    }
-                )
+                error_msg = f"\n❌ **JSON Parse Error:** {str(e)}\n"
+                yield error_msg
+                tool_results.append({"type": "error", "error": str(e), "success": False})
             except Exception as e:
-                tool_results.append(
-                    {"type": "error", "display": f"\n❌ **Tool Error:** {str(e)}\n"}
-                )
-
-        # Now yield the tool results
-        if tool_results:
-            # Show all tool results
-            for tool_result in tool_results:
-                yield tool_result["display"]
+                error_msg = f"\n❌ **Tool Error:** {str(e)}\n"
+                yield error_msg
+                tool_results.append({"type": "error", "error": str(e), "success": False})
 
-            # Check if we should end the response (end_response tool was called)
-            if should_end_response:
-                return
+        # Tool results have already been yielded immediately during execution
+        # Now check if we should continue or end
+        
+        # Check if we should end the response (end_response tool was called)
+        if should_end_response:
+            return
 
-            # Use auto-continuation manager to determine if we should continue
-            if self.auto_continuation.should_continue(tool_results, should_end_response) and recursion_depth < MAX_RECURSION_DEPTH:
+        # Use auto-continuation manager to determine if we should continue
+        if has_executed_tools and self.auto_continuation.should_continue(tool_results, should_end_response) and recursion_depth < MAX_RECURSION_DEPTH:
                 # Show continuation indicator
                 yield "\n🔄 **Auto-continuing...**\n"
                 
@@ -1389,7 +1621,11 @@ CRITICAL BEHAVIOR REQUIREMENTS:
 - PROVIDE COMPREHENSIVE SOLUTIONS: Don't stop after creating just one file - complete the entire functional project.
 - BE PROACTIVE: Anticipate what files and functionality are needed and create them all without asking for permission for each step.
 - EXPLORATION IS OPTIONAL: You may explore the workspace with 'ls' or 'pwd' if needed, but this is NOT required before creating new files. If the user asks you to BUILD or CREATE something, prioritize creating the files immediately.
-- ALWAYS USE end_response TOOL: When you have completed ALL tasks, ALWAYS call the end_response tool to prevent unnecessary continuation
+- ALWAYS USE end_response TOOL: When you have completed ALL tasks, you MUST call the end_response tool to signal completion. This prevents unnecessary auto-continuation.
+- AUTO-CONTINUATION: The system will automatically continue ONLY when:
+  * You created files but haven't run necessary commands yet (e.g., npm install after creating package.json)
+  * There were errors that need to be handled
+  * Otherwise, you MUST explicitly call end_response when done
 - NEVER RE-READ SAME FILE: If a file was truncated in the output, use read_file_lines to read the specific truncated section, DO NOT re-read the entire file
 
 WORKSPACE EXPLORATION RULES (CRITICAL - ALWAYS CHECK FIRST):
@@ -1569,7 +1805,7 @@ For multiple files, use separate tool calls:
 }
 ```
 
-For commands (always explore first):
+For commands:
 
 ```json
 {
@@ -1580,16 +1816,44 @@ For commands (always explore first):
 }
 ```
 
+For LONG commands (npm install, servers), use run_async_command to run in background:
+
 ```json
 {
   "tool_code": "command_runner",
   "args": {
-    "command": "pwd"
+    "operation": "run_async_command",
+    "command": "npm install"
+  }
+}
+```
+
+For file reading and grep:
+
+```json
+{
+  "tool_code": "file_reader",
+  "args": {
+    "operation": "read_file",
+    "file_path": "src/App.js"
+  }
+}
+```
+
+```json
+{
+  "tool_code": "file_reader",
+  "args": {
+    "operation": "grep_search",
+    "pattern": "function.*Component",
+    "search_path": "src",
+    "file_pattern": "*.js",
+    "recursive": true
   }
 }
 ```
 
-For web search (when you need external information):
+For web search:
 
 ```json
 {
@@ -1672,11 +1936,11 @@ When user explicitly asks for RESEARCH:
 The tools will execute automatically and show results. Keep explanatory text BRIEF.
 
 Available tools:
-- file_operations: Create, read, write, delete files and directories
-- command_runner: Execute shell commands
+- file_operations: Create, read, write, delete files
+- file_reader: Read files, grep search, list directories  
+- command_runner: Execute shell commands (use run_async_command for long tasks)
 - web_search: Search the web for information
-- code_analysis: Analyze code files
-- response_control: Control response continuation (use end_response to stop auto-continuation)
+- response_control: Use end_response when task is complete
 
 RESPONSE CONTINUATION (CRITICAL - ALWAYS USE end_response):
 - By default, after executing tools, the AI will automatically continue to complete the task

cognautic/auto_continuation.py

@@ -43,8 +43,60 @@ class AutoContinuationManager:
         if self.iteration_count >= self.max_iterations:
             return False
         
-        # Continue if there were tool executions
-        if tool_results:
+        # 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', 'file_read'] for r in tool_results)
+        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 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
+        )
+        
+        # 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 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
+        
+        # 3. If only exploratory commands (ls, pwd, etc.), continue to do actual work
+        if has_exploratory_commands and not has_file_ops:
+            self.iteration_count += 1
+            return True
+        
+        # 4. If background commands were started AND files created, task likely complete
+        if has_background_commands and has_file_ops:
+            return False
+        
+        # 5. If only background commands (no files), don't continue (they're running)
+        if has_background_commands and not has_file_ops:
+            return False
+        
+        # 6. If regular commands executed with file ops, task likely complete
+        if has_commands and has_file_ops and not has_exploratory_commands:
+            return False
+        
+        # 7. Default: Continue if we're early in the process
+        # This ensures AI completes the full task
+        if self.iteration_count < 3:
             self.iteration_count += 1
             return True
         

cognautic/cli.py

@@ -8,8 +8,12 @@ import logging
 import os
 import readline
 import signal
-import sys
 from pathlib import Path
+import sys
+import subprocess
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.formatted_text import HTML
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
@@ -83,7 +87,7 @@ def signal_handler(signum, frame):
 
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.1.1", prog_name="Cognautic CLI")
+@click.version_option(version="1.1.2", prog_name="Cognautic CLI")
 @click.pass_context
 def main(ctx):
     """Cognautic CLI - AI-powered development assistant"""
@@ -193,6 +197,7 @@ def chat(provider, model, project_path, websocket_port, session):
         
         try:
             console.print("💡 Type '/help' for commands, 'exit' to quit")
+            console.print("💡 Press Shift+Tab to toggle Terminal mode")
             if project_path:
                 console.print(f"📁 Working in: {project_path}")
             
@@ -238,21 +243,81 @@ def chat(provider, model, project_path, websocket_port, session):
             # Show current workspace
             console.print(f"📁 Workspace: {current_workspace}")
             
+            # Terminal mode state
+            terminal_mode = [False]  # Use list to make it mutable in nested function
+            
+            # Setup key bindings for Shift+Tab toggle
+            bindings = KeyBindings()
+            
+            @bindings.add('s-tab')  # Shift+Tab
+            def toggle_mode(event):
+                terminal_mode[0] = not terminal_mode[0]
+                mode_name = "🖥️  Terminal" if terminal_mode[0] else "💬 Chat"
+                # Clear current line and show mode switch message
+                event.app.current_buffer.text = ''
+                event.app.exit(result='__MODE_TOGGLE__')
+            
+            # Create prompt session
+            session = PromptSession(key_bindings=bindings)
+            
+            console.print("[dim]💡 Press Shift+Tab to toggle between Chat and Terminal modes[/dim]\n")
+            
             while True:
                 try:
-                    # Show current workspace in prompt
+                    # Show current workspace and mode in prompt
                     workspace_info = f" [{Path(current_workspace).name}]" if current_workspace else ""
+                    mode_indicator = "🖥️ " if terminal_mode[0] else ""
                     
-                    # Use readline delimiters for non-printing characters to fix text reordering
-                    # \001 and \002 tell readline that the enclosed characters don't take up space
-                    # This prevents cursor position issues when editing
-                    # ANSI color codes: \033[1;36m = bold cyan, \033[0m = reset
-                    prompt = f"\001\033[1;36m\002You{workspace_info}:\001\033[0m\002 "
-                    user_input = input(prompt)
+                    prompt_text = HTML(f'<ansibrightcyan><b>{mode_indicator}You{workspace_info}:</b></ansibrightcyan> ')
+                    user_input = await session.prompt_async(prompt_text)
+                    
+                    # Handle mode toggle
+                    if user_input == '__MODE_TOGGLE__':
+                        mode_name = "🖥️  Terminal" if terminal_mode[0] else "💬 Chat"
+                        console.print(f"[bold yellow]Switched to {mode_name} mode[/bold yellow]")
+                        console.print("[dim]Press Shift+Tab to toggle modes[/dim]")
+                        continue
                     
                     if user_input.lower() in ['exit', 'quit']:
                         break
                     
+                    # Handle terminal mode
+                    if terminal_mode[0]:
+                        if not user_input.strip():
+                            continue
+                        
+                        # Execute command in terminal mode
+                        try:
+                            # Change to current workspace directory
+                            original_dir = os.getcwd()
+                            os.chdir(current_workspace)
+                            
+                            # Run command and capture output
+                            result = subprocess.run(
+                                user_input,
+                                shell=True,
+                                capture_output=True,
+                                text=True,
+                                cwd=current_workspace
+                            )
+                            
+                            # Show output
+                            if result.stdout:
+                                console.print(result.stdout, end='')
+                            if result.stderr:
+                                console.print(f"[red]{result.stderr}[/red]", end='')
+                            
+                            # Show exit code if non-zero
+                            if result.returncode != 0:
+                                console.print(f"[yellow]Exit code: {result.returncode}[/yellow]")
+                            
+                            # Change back to original directory
+                            os.chdir(original_dir)
+                            
+                        except Exception as e:
+                            console.print(f"[red]Error executing command: {str(e)}[/red]")
+                        
+                        continue
                     
                     # Handle slash commands
                     if user_input.startswith('/'):
@@ -1022,6 +1087,58 @@ async def handle_slash_command(command, config_manager, ai_engine, context):
         console.print("💬 Chat cleared")
         return True
     
+    elif cmd == "ps" or cmd == "processes":
+        # List all running background processes
+        try:
+            result = await ai_engine.tool_registry.execute_tool(
+                "command_runner",
+                operation="check_process_status",
+                user_id="ai_engine"
+            )
+            
+            if result.success and result.data:
+                processes = result.data.get('processes', [])
+                if not processes:
+                    console.print("📋 No background processes running", style="dim")
+                else:
+                    console.print(f"\n📋 Running Processes ({len(processes)}):", style="bold")
+                    for proc in processes:
+                        status_color = "green" if proc['status'] == 'running' else "yellow"
+                        console.print(f"  • PID: {proc['process_id']} - {proc['command'][:50]}... [{proc['status']}]", style=status_color)
+                        console.print(f"    Running for: {proc['running_time']:.1f}s", style="dim")
+                    console.print("\n💡 Use /ct <process_id> to terminate a process\n", style="dim")
+            else:
+                console.print("❌ Failed to get process list", style="red")
+        except Exception as e:
+            console.print(f"❌ Error: {str(e)}", style="red")
+        
+        return True
+    
+    elif cmd == "ct" or cmd == "cancel":
+        # Cancel/terminate a background process
+        if len(parts) < 2:
+            console.print("❌ Usage: /ct <process_id>", style="red")
+            console.print("💡 Tip: Process IDs are shown when commands run in background", style="dim")
+            return True
+        
+        process_id = parts[1]
+        try:
+            result = await ai_engine.tool_registry.execute_tool(
+                "command_runner",
+                operation="kill_process",
+                process_id=process_id,
+                user_id="ai_engine"
+            )
+            
+            if result.success:
+                console.print(f"✅ Process {process_id} terminated successfully", style="green")
+            else:
+                console.print(f"❌ Failed to terminate process: {result.error}", style="red")
+        except Exception as e:
+            console.print(f"❌ Error: {str(e)}", style="red")
+        
+        return True
+    
     elif cmd == "exit" or cmd == "quit":
         return False
     
@@ -1033,6 +1150,7 @@ def show_help():
     """Show help information"""
     help_text = Text()
     help_text.append("Available commands:\n", style="bold")
+    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")
     help_text.append("• /setup - Run interactive setup wizard\n")
@@ -1050,6 +1168,8 @@ def show_help():
     help_text.append("  - /rules remove workspace <index> - Remove a workspace rule\n", style="dim")
     help_text.append("  - /rules clear global|workspace - Clear all rules of a type\n", style="dim")
     help_text.append("• /speed [instant|fast|normal|slow|<number>] - Set typing speed for AI responses\n")
+    help_text.append("• /ps or /processes - List all running background processes\n")
+    help_text.append("• /ct <process_id> or /cancel <process_id> - Terminate a background process\n")
     help_text.append("• /clear - Clear chat screen\n")
     help_text.append("• /exit or /quit - Exit chat session\n")
     help_text.append("• exit or quit - Exit chat session\n")

cognautic/tools/file_reader.py

@@ -0,0 +1,218 @@
+"""
+File reader tool for reading and searching files
+"""
+
+import os
+import re
+from typing import List, Dict, Any
+from pathlib import Path
+
+from .base import BaseTool, ToolResult, PermissionLevel
+
+
+class FileReaderTool(BaseTool):
+    """Tool for reading files and searching content"""
+    
+    def __init__(self):
+        super().__init__(
+            name="file_reader",
+            description="Read file contents and search in files",
+            permission_level=PermissionLevel.READ_ONLY
+        )
+    
+    def get_capabilities(self) -> List[str]:
+        return [
+            "read_file",
+            "grep_search",
+            "list_directory"
+        ]
+    
+    async def execute(self, operation: str, **kwargs) -> ToolResult:
+        """Execute file reader operation"""
+        
+        operations = {
+            'read_file': self._read_file,
+            'grep_search': self._grep_search,
+            'list_directory': self._list_directory
+        }
+        
+        if operation not in operations:
+            return ToolResult(
+                success=False,
+                error=f"Unknown operation: {operation}"
+            )
+        
+        try:
+            result = await operations[operation](**kwargs)
+            return ToolResult(success=True, data=result)
+        except Exception as e:
+            return ToolResult(success=False, error=str(e))
+    
+    async def _read_file(
+        self,
+        file_path: str,
+        start_line: int = None,
+        end_line: int = None,
+        max_lines: int = 1000
+    ) -> Dict[str, Any]:
+        """Read file contents"""
+        
+        try:
+            path = Path(file_path).expanduser().resolve()
+            
+            if not path.exists():
+                raise FileNotFoundError(f"File not found: {file_path}")
+            
+            if not path.is_file():
+                raise ValueError(f"Not a file: {file_path}")
+            
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                lines = f.readlines()
+            
+            total_lines = len(lines)
+            
+            if start_line is not None or end_line is not None:
+                start = (start_line - 1) if start_line else 0
+                end = end_line if end_line else total_lines
+                lines = lines[start:end]
+            
+            if len(lines) > max_lines:
+                lines = lines[:max_lines]
+                truncated = True
+            else:
+                truncated = False
+            
+            content = ''.join(lines)
+            
+            return {
+                'file_path': str(path),
+                'content': content,
+                'total_lines': total_lines,
+                'lines_returned': len(lines),
+                'truncated': truncated
+            }
+            
+        except Exception as e:
+            raise Exception(f"Failed to read file: {str(e)}")
+    
+    async def _grep_search(
+        self,
+        pattern: str,
+        search_path: str,
+        file_pattern: str = "*",
+        recursive: bool = True,
+        case_sensitive: bool = False,
+        max_results: int = 100
+    ) -> Dict[str, Any]:
+        """Search for pattern in files"""
+        
+        try:
+            search_path = Path(search_path).expanduser().resolve()
+            
+            if not search_path.exists():
+                raise FileNotFoundError(f"Path not found: {search_path}")
+            
+            results = []
+            flags = 0 if case_sensitive else re.IGNORECASE
+            regex = re.compile(pattern, flags)
+            
+            if search_path.is_file():
+                files_to_search = [search_path]
+            else:
+                if recursive:
+                    files_to_search = list(search_path.rglob(file_pattern))
+                else:
+                    files_to_search = list(search_path.glob(file_pattern))
+                
+                files_to_search = [f for f in files_to_search if f.is_file()]
+            
+            for file_path in files_to_search:
+                if len(results) >= max_results:
+                    break
+                
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        for line_num, line in enumerate(f, 1):
+                            if len(results) >= max_results:
+                                break
+                            
+                            if regex.search(line):
+                                results.append({
+                                    'file': str(file_path),
+                                    'line_number': line_num,
+                                    'line_content': line.rstrip('\n'),
+                                    'match': regex.search(line).group(0)
+                                })
+                except Exception:
+                    continue
+            
+            return {
+                'pattern': pattern,
+                'search_path': str(search_path),
+                'total_matches': len(results),
+                'matches': results,
+                'truncated': len(results) >= max_results
+            }
+            
+        except Exception as e:
+            raise Exception(f"Failed to search: {str(e)}")
+    
+    async def _list_directory(
+        self,
+        directory_path: str,
+        show_hidden: bool = False,
+        recursive: bool = False,
+        max_depth: int = 3
+    ) -> Dict[str, Any]:
+        """List directory contents"""
+        
+        try:
+            path = Path(directory_path).expanduser().resolve()
+            
+            if not path.exists():
+                raise FileNotFoundError(f"Directory not found: {directory_path}")
+            
+            if not path.is_dir():
+                raise ValueError(f"Not a directory: {directory_path}")
+            
+            items = []
+            
+            if recursive:
+                for item in path.rglob('*'):
+                    if not show_hidden and item.name.startswith('.'):
+                        continue
+                    
+                    try:
+                        relative = item.relative_to(path)
+                        depth = len(relative.parts)
+                        if depth > max_depth:
+                            continue
+                    except ValueError:
+                        continue
+                    
+                    items.append({
+                        'path': str(item),
+                        'name': item.name,
+                        'type': 'directory' if item.is_dir() else 'file',
+                        'size': item.stat().st_size if item.is_file() else None
+                    })
+            else:
+                for item in path.iterdir():
+                    if not show_hidden and item.name.startswith('.'):
+                        continue
+                    
+                    items.append({
+                        'path': str(item),
+                        'name': item.name,
+                        'type': 'directory' if item.is_dir() else 'file',
+                        'size': item.stat().st_size if item.is_file() else None
+                    })
+            
+            return {
+                'directory': str(path),
+                'total_items': len(items),
+                'items': items
+            }
+            
+        except Exception as e:
+            raise Exception(f"Failed to list directory: {str(e)}")

cognautic/tools/registry.py

@@ -48,6 +48,7 @@ class ToolRegistry:
         from .web_search import WebSearchTool
         from .code_analysis import CodeAnalysisTool
         from .response_control import ResponseControlTool
+        from .file_reader import FileReaderTool
         
         # Register tools
         self.register_tool(FileOperationsTool())
@@ -55,6 +56,7 @@ class ToolRegistry:
         self.register_tool(WebSearchTool())
         self.register_tool(CodeAnalysisTool())
         self.register_tool(ResponseControlTool())
+        self.register_tool(FileReaderTool())
     
     def register_tool(self, tool: BaseTool):
         """Register a tool"""

{cognautic_cli-1.1.1.dist-info → cognautic_cli-1.1.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: cognautic-cli
-Version: 1.1.1
+Version: 1.1.2
 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/cli
-Author: cognautic
-Author-email: cognautic <cognautic@gmail.com>
-Maintainer-email: cognautic <cognautic@gmail.com>
+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
 Project-URL: Homepage, https://github.com/cognautic/cli
 Project-URL: Documentation, https://cognautic.vercel.app/cognautic-cli.html
@@ -43,6 +43,7 @@ Requires-Dist: anthropic>=0.7.0
 Requires-Dist: google-generativeai>=0.3.0
 Requires-Dist: together>=0.2.0
 Requires-Dist: nest-asyncio>=1.5.0
+Requires-Dist: prompt-toolkit>=3.0.0
 Provides-Extra: tools
 Requires-Dist: gitpython>=3.1.0; extra == "tools"
 Requires-Dist: pyyaml>=6.0; extra == "tools"
@@ -78,7 +79,7 @@ Cognautic CLI is a Python-based command-line interface that brings AI-powered de
 
 | Property | Value |
 |----------|-------|
-| **Developer** | cognautic |
+| **Developer** | Cognautic |
 | **Written in** | Python |
 | **Operating system** | Cross-platform |
 | **Type** | AI Development Tool |
@@ -597,8 +598,4 @@ You: /model claude-3-sonnet-20240229
 
 ## License
 
-Proprietary - All Rights Reserved
-
-© 2024 cognautic
-
-For licensing inquiries, contact: cognautic@gmail.com
+MIT

{cognautic_cli-1.1.1.dist-info → cognautic_cli-1.1.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-cognautic/__init__.py,sha256=91wlZSHl8xT0VU8eNejpMjcnpciKtuVm8QCSy9Tal10,140
-cognautic/ai_engine.py,sha256=kMnbZXZWnE8n9ndbItfoJmcjzxvRDgvHeMgXMwj6bNI,92428
-cognautic/auto_continuation.py,sha256=1YxdXJCm3cNaHer4c8Had49VepAnUrYcsU5nVYwQTIA,6773
-cognautic/cli.py,sha256=VEdEgMeDTNh2uTeDdTMUcLBUpDEmqzXSqXh__npIw9c,50741
+cognautic/__init__.py,sha256=Wn_G_YckyznLr_f_1-MsYNMuCyHtHomSp2qYHWxiEqE,141
+cognautic/ai_engine.py,sha256=W9liShtN7KL8jnDPcSR6BeqRT9xmtBBQnIx-FJTyuag,106097
+cognautic/auto_continuation.py,sha256=-jJU17fdo6Ww26wtLxO8PkQ5itsARmrNlCFroMgCZSM,9032
+cognautic/cli.py,sha256=Leutgyw3WKLovSsRwxsGPGKeeoAnumDxSnxN7CCWUW4,56518
 cognautic/config.py,sha256=mrkvBA2gz_i9PuER6K75RxVeLBcYbjwNYBV2NskFQVk,9115
 cognautic/file_tagger.py,sha256=DBsBIggtI0pGdbxY9XOMHtVG1k9RYCihqrAEfM68xGI,8532
 cognautic/memory.py,sha256=5oLWmkaIy5rEJ1yJ4xldJIzDfvvAKqkxz0PWk53heis,15208
@@ -14,12 +14,13 @@ cognautic/tools/base.py,sha256=PtEMTyntWwhO-SFtkMSSnhR0TXrCWqUy5Tg_yPIldCk,1590
 cognautic/tools/code_analysis.py,sha256=rWS-yz0yzmF33IEHhJsN22j4e26WDDa7Fv30PF3zBhk,15387
 cognautic/tools/command_runner.py,sha256=-C3VaSlFyZOiytxizspnz-PDONdrfut4rOXh3Vbbb6M,10032
 cognautic/tools/file_operations.py,sha256=_p_e5ZQq3Q8TGL21cRyIDoaeuDshz3_-h_C5kMLnc68,14073
-cognautic/tools/registry.py,sha256=5ykVeH43YcdJ8YcmwtBrtmNM2jzh55-yxWXfVqJ0ltw,3862
+cognautic/tools/file_reader.py,sha256=IAi4mCnauIghlWiBshTp_ZYJ_XyWqpnEJ7gJuD4NxvA,7435
+cognautic/tools/registry.py,sha256=Dk_tgj2FyLerha2k92PIgLfLlOw0vTsgzw3t3_3W4Hw,3955
 cognautic/tools/response_control.py,sha256=rb9h5mYi80uc-izUkuCcaUXOeonigX-zFvzeUlTBwcE,1480
 cognautic/tools/web_search.py,sha256=tXHy1oB_33_peopJu3Xc7k7_NWuZNfLGfXzv9w7p9bM,13863
-cognautic_cli-1.1.1.dist-info/licenses/LICENSE,sha256=N_qTILhnbmexBombE-njuJguCu9u2b1gwCvOVKnFWno,1066
-cognautic_cli-1.1.1.dist-info/METADATA,sha256=6HxmJ-r_kYQWb5cXihk3WQKJGp3QHxA-JljeysScWco,17538
-cognautic_cli-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cognautic_cli-1.1.1.dist-info/entry_points.txt,sha256=QoF70RcDm_QElmIC7pkmhbFsWhuWSbxQksGaFXKBs8Q,49
-cognautic_cli-1.1.1.dist-info/top_level.txt,sha256=zikDi43HL2zOV9cF_PAv6RBhJruTjSk6AMkIOTX12do,10
-cognautic_cli-1.1.1.dist-info/RECORD,,
+cognautic_cli-1.1.2.dist-info/licenses/LICENSE,sha256=N_qTILhnbmexBombE-njuJguCu9u2b1gwCvOVKnFWno,1066
+cognautic_cli-1.1.2.dist-info/METADATA,sha256=K-F7985c4YQtGw55hIp6hn-SUPG8Kk-P3S9A5R2PZNk,17481
+cognautic_cli-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cognautic_cli-1.1.2.dist-info/entry_points.txt,sha256=QoF70RcDm_QElmIC7pkmhbFsWhuWSbxQksGaFXKBs8Q,49
+cognautic_cli-1.1.2.dist-info/top_level.txt,sha256=zikDi43HL2zOV9cF_PAv6RBhJruTjSk6AMkIOTX12do,10
+cognautic_cli-1.1.2.dist-info/RECORD,,