nc1709 1.15.4__py3-none-any.whl → 1.18.8__py3-none-any.whl

nc1709/__init__.py

@@ -5,7 +5,7 @@ Author: Lafzusa Corp
 License: Proprietary
 """
 
-__version__ = "1.15.4"
+__version__ = "1.18.8"
 __author__ = "Lafzusa Corp"
 
 from .cli import main

nc1709/agent/core.py

@@ -27,7 +27,7 @@ try:
     from ..cli_ui import (
         ActionSpinner, Color, Icons,
         status, thinking, success, error, warning, info,
-        log_action
+        log_action, log_output
     )
     HAS_CLI_UI = True
 except ImportError:
@@ -50,6 +50,7 @@ class AgentConfig:
     max_iterations: int = 50
     max_tool_retries: int = 3
     max_same_error_retries: int = 2  # Max times to retry the same failing command
+    max_alternating_loops: int = 3  # Max alternating pattern repetitions (e.g., Read→Edit→Read→Edit)
     tool_permissions: Dict[str, ToolPermission] = field(default_factory=dict)
     auto_approve_tools: List[str] = field(default_factory=lambda: [
         "Read", "Glob", "Grep", "TodoWrite"
@@ -93,13 +94,23 @@ To use a tool, include a tool call in your response using this exact format:
 {{"tool": "ToolName", "parameters": {{"param1": "value1", "param2": "value2"}}}}
 ```
 
+## CRITICAL: When to STOP
+
+You MUST stop and provide a final summary (without tool calls) when:
+- A command/script runs successfully (exit code 0)
+- The requested file has been created/edited
+- The task is complete
+- You've already run the same command successfully - DO NOT run it again
+
+NEVER repeat the same successful tool call. If `python example.py` succeeds once, the task is DONE.
+
 ## Guidelines
 
 1. **Read before writing**: Always read files before modifying them
 2. **Be precise**: Use exact file paths and specific parameters
 3. **Explain your actions**: Briefly explain what you're doing and why
 4. **Handle errors**: If a tool fails, try a DIFFERENT approach instead of repeating the same command
-5. **Complete the task**: Keep working until the task is fully complete
+5. **Know when to stop**: Once a task succeeds, STOP and summarize - don't repeat it
 6. **Ask if unclear**: Use AskUser if you need clarification
 
 ## Building New Projects - IMPORTANT
@@ -174,6 +185,10 @@ Working directory: {cwd}
         self._failed_commands: Dict[str, int] = {}  # command_signature -> failure_count
         self._last_error: Optional[str] = None
 
+        # Advanced loop detection
+        self._tool_sequence: List[str] = []  # Track tool names for pattern detection
+        self._successful_commands: set = set()  # Track commands that already succeeded
+
         # Apply permission settings
         self._apply_permission_config()
 
@@ -219,6 +234,7 @@ Working directory: {cwd}
         self.iteration_count = 0
         self.conversation_history = []
         self.tool_results = []
+        self._recent_tool_calls = []  # Track recent calls for loop detection
 
         # Build system prompt with tools
         import os
@@ -256,6 +272,17 @@ Working directory: {cwd}
                     self.state = AgentState.COMPLETED
                     return self._clean_response(response)
 
+                # Detect loops - same tool call made 3+ times
+                current_call_sig = [(tc.name, str(tc.arguments)) for tc in tool_calls]
+                self._recent_tool_calls.append(current_call_sig)
+                if len(self._recent_tool_calls) >= 3:
+                    last_three = self._recent_tool_calls[-3:]
+                    if last_three[0] == last_three[1] == last_three[2]:
+                        if HAS_CLI_UI:
+                            warning("Detected loop - same tool called 3 times. Stopping.")
+                        self.state = AgentState.COMPLETED
+                        return "Task completed (detected repetitive tool calls)."
+
                 # Execute tool calls
                 all_results = []
                 for tool_call in tool_calls:
@@ -269,9 +296,68 @@ Working directory: {cwd}
                     "role": "assistant",
                     "content": response,
                 })
+
+                # Check if all tools succeeded - if so, strongly hint task may be done
+                all_succeeded = all(r.success for r in all_results)
+                has_bash = any(tc.name == "Bash" for tc in tool_calls)
+                has_write = any(tc.name in ["Write", "Edit"] for tc in tool_calls)
+
+                # Check for silent success (command succeeded but no output)
+                silent_success = all_succeeded and all(
+                    not r.output.strip() for r in all_results
+                )
+
+                if all_succeeded and has_bash:
+                    # Bash command succeeded - task is likely complete
+                    if silent_success:
+                        follow_up = (
+                            f"Tool results:\n{results_text}\n\n"
+                            "The command completed successfully with no output (exit code 0). "
+                            "This typically means the operation succeeded. "
+                            "Provide a final summary of what was accomplished WITHOUT any more tool calls."
+                        )
+                    else:
+                        follow_up = (
+                            f"Tool results:\n{results_text}\n\n"
+                            "The command executed successfully. "
+                            "If this completes the user's request, provide a final summary WITHOUT any tool calls. "
+                            "Only use more tools if there are additional steps needed."
+                        )
+                elif all_succeeded and has_write:
+                    # File was written/edited successfully
+                    follow_up = (
+                        f"Tool results:\n{results_text}\n\n"
+                        "The file was successfully created/modified. "
+                        "If this completes the task, provide a summary. "
+                        "Do NOT read the file back unless the user asked to verify it."
+                    )
+                elif all_succeeded:
+                    follow_up = (
+                        f"Tool results:\n{results_text}\n\n"
+                        "All tools succeeded. Provide a summary if the task is complete, or continue with the next step."
+                    )
+                else:
+                    # Some failed - analyze failure type
+                    failed_results = [r for r in all_results if not r.success]
+                    loop_detected = any("LOOP" in (r.error or "") or "REDUNDANT" in (r.error or "") for r in failed_results)
+
+                    if loop_detected:
+                        follow_up = (
+                            f"Tool results:\n{results_text}\n\n"
+                            "A loop or redundant operation was detected. "
+                            "STOP and either: 1) Provide a final summary if the task is done, or "
+                            "2) Explain what's blocking progress and ask the user for guidance."
+                        )
+                    else:
+                        follow_up = (
+                            f"Tool results:\n{results_text}\n\n"
+                            "Some tools failed. Try a DIFFERENT approach - don't repeat the same command. "
+                            "If you've tried multiple approaches without success, ask the user for help."
+                        )
+
                 self.conversation_history.append({
                     "role": "user",
-                    "content": f"Tool results:\n{results_text}\n\nContinue with the task.",
+                    "content": follow_up,
                 })
 
             except Exception as e:
@@ -350,16 +436,62 @@ Working directory: {cwd}
             Warning message if loop detected, None otherwise
         """
         sig = self._get_command_signature(tool_call)
-        fail_count = self._failed_commands.get(sig, 0)
 
+        # Check 1: Same command failed too many times
+        fail_count = self._failed_commands.get(sig, 0)
         if fail_count >= self.config.max_same_error_retries:
             return (
                 f"LOOP DETECTED: This command has failed {fail_count} times with the same error. "
                 f"You MUST try a DIFFERENT approach instead of repeating this command. "
                 f"Last error: {self._last_error}"
             )
+
+        # Check 2: Trying to repeat a command that already succeeded
+        if sig in self._successful_commands:
+            return (
+                f"REDUNDANT COMMAND: This exact command already succeeded. "
+                f"Do NOT repeat it. If the task is complete, provide a summary. "
+                f"If you need different output, modify the command parameters."
+            )
+
+        return None
+
+    def _check_alternating_pattern(self) -> Optional[str]:
+        """Detect alternating tool patterns like Read→Edit→Read→Edit
+
+        Returns:
+            Warning message if pattern detected, None otherwise
+        """
+        seq = self._tool_sequence
+        if len(seq) < 4:
+            return None
+
+        # Check for 2-tool alternating pattern (e.g., Read→Edit→Read→Edit)
+        if len(seq) >= 6:
+            last_six = seq[-6:]
+            if (last_six[0] == last_six[2] == last_six[4] and
+                last_six[1] == last_six[3] == last_six[5] and
+                last_six[0] != last_six[1]):
+                return (
+                    f"ALTERNATING LOOP DETECTED: Pattern {last_six[0]}→{last_six[1]} repeated 3 times. "
+                    f"You appear to be stuck in a loop. Stop and summarize what you've accomplished, "
+                    f"or try a completely different approach."
+                )
+
+        # Check for single-tool repetition (already covered elsewhere but double-check)
+        if len(seq) >= 4 and seq[-1] == seq[-2] == seq[-3] == seq[-4]:
+            return (
+                f"REPETITION DETECTED: {seq[-1]} called 4 times in a row. "
+                f"Stop repeating and either complete the task or try a different approach."
+            )
+
         return None
 
+    def _record_success(self, tool_call: ToolCall) -> None:
+        """Record a successful command to prevent redundant repeats"""
+        sig = self._get_command_signature(tool_call)
+        self._successful_commands.add(sig)
+
     def _record_failure(self, tool_call: ToolCall, error: str) -> None:
         """Record a command failure for loop detection"""
         sig = self._get_command_signature(tool_call)
@@ -379,7 +511,10 @@ Working directory: {cwd}
                 target=str(tool_call.parameters)[:30],
             )
 
-        # Loop detection - check if this command has failed too many times
+        # Track tool sequence for alternating pattern detection
+        self._tool_sequence.append(tool_call.name)
+
+        # Loop detection - check if this command has failed too many times or already succeeded
         loop_warning = self._check_loop_detection(tool_call)
         if loop_warning:
             if HAS_CLI_UI:
@@ -392,6 +527,19 @@ Working directory: {cwd}
                 target=tool._get_target(**tool_call.parameters),
             )
 
+        # Check for alternating tool patterns
+        alt_warning = self._check_alternating_pattern()
+        if alt_warning:
+            if HAS_CLI_UI:
+                warning("Alternating pattern detected")
+            return ToolResult(
+                success=False,
+                output="",
+                error=alt_warning,
+                tool_name=tool_call.name,
+                target=tool._get_target(**tool_call.parameters),
+            )
+
         # Check permission - special handling for Bash with safe commands
         needs_approval = self.registry.needs_approval(tool_call.name)
 
@@ -422,20 +570,19 @@ Working directory: {cwd}
 
         result = tool.run(**tool_call.parameters)
 
-        # Track failures for loop detection
-        if not result.success:
+        # Track results for loop detection
+        if result.success:
+            self._record_success(tool_call)
+        else:
             self._record_failure(tool_call, result.error or "Unknown error")
 
         if HAS_CLI_UI:
-            state = "success" if result.success else "error"
-            if self.config.verbose or not result.success:
-                log_action(tool_call.name, result.target, state)
-                if self.config.show_tool_output and result.output:
-                    # Show truncated output
-                    output = result.output[:500]
-                    if len(result.output) > 500:
-                        output += "..."
-                    print(f"    {Color.DIM}{output}{Color.RESET}")
+            # Show output using Claude Code style (corner indentation)
+            if self.config.show_tool_output:
+                if result.success and result.output:
+                    log_output(result.output, is_error=False, max_lines=15)
+                elif not result.success and result.error:
+                    log_output(result.error, is_error=True, max_lines=10)
 
         return result
 
@@ -444,11 +591,17 @@ Working directory: {cwd}
         tool = self.registry.get(tool_call.name)
         target = tool._get_target(**tool_call.parameters) if tool else ""
 
-        print(f"\n{Color.YELLOW}⚠ Tool requires approval:{Color.RESET}")
-        print(f"  {Color.BOLD}{tool_call.name}{Color.RESET}({Color.CYAN}{target}{Color.RESET})")
+        # Claude Code style approval prompt
+        print(f"\n{Color.YELLOW}{Icons.BULLET}{Color.RESET} {Color.BOLD}{tool_call.name}{Color.RESET}({Color.CYAN}{target}{Color.RESET})")
 
         if tool_call.parameters:
-            print(f"  Parameters: {json.dumps(tool_call.parameters, indent=2)[:200]}")
+            # Show parameters with corner indentation
+            params_str = json.dumps(tool_call.parameters, indent=2)
+            for i, line in enumerate(params_str.split('\n')[:5]):
+                if i == 0:
+                    print(f"  {Color.DIM}{Icons.CORNER}{Color.RESET}  {Color.DIM}{line}{Color.RESET}")
+                else:
+                    print(f"      {Color.DIM}{line}{Color.RESET}")
 
         response = input(f"\n{Color.BOLD}Allow?{Color.RESET} [y/N/always]: ").strip().lower()
 

nc1709/agent/permissions.py

@@ -32,7 +32,7 @@ class PermissionRule:
 @dataclass
 class PermissionConfig:
     """Configuration for the permissions system"""
-    policy: PermissionPolicy = PermissionPolicy.NORMAL
+    policy: PermissionPolicy = PermissionPolicy.PERMISSIVE  # Default to permissive for better UX
     custom_rules: List[PermissionRule] = field(default_factory=list)
     blocked_tools: Set[str] = field(default_factory=set)
     session_approvals: Set[str] = field(default_factory=set)
@@ -61,7 +61,7 @@ class PermissionManager:
         },
         PermissionPolicy.PERMISSIVE: {
             "default": ToolPermission.AUTO,
-            "ask": ["Bash", "Write", "Edit", "Task", "BackgroundBash"],
+            "ask": ["Write", "Edit"],  # Only ask for file modifications, auto-approve Bash/Task
         },
         PermissionPolicy.TRUST: {
             "default": ToolPermission.AUTO,