gitarsenal-cli 1.9.52 → 1.9.53

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-12T12:09:30.316Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-12T14:24:06.005Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.52",
+  "version": "1.9.53",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/test_modalSandboxScript.py

@@ -15,13 +15,118 @@ import uuid
 import signal
 from pathlib import Path
 import modal
+import io
+import contextlib
+import unicodedata
+import shutil
+from auth_manager import AuthManager
 
-# Import authentication manager
-try:
-    from auth_manager import AuthManager
-except ImportError:
-    print("❌ Authentication module not found. Please ensure auth_manager.py is in the same directory.")
-    sys.exit(1)
+# Global flag to indicate when an outer boxed capture is active
+_BOX_CAPTURE_ACTIVE = False
+
+
+def _print_boxed_block(content: str):
+    # Use NBSP for padding to prevent renderers from trimming trailing spaces
+    NBSP = "\u00A0"
+    lines = content.splitlines() if content else ["(no output)"]
+
+    def _strip_ansi(s: str) -> str:
+        return re.sub(r"\x1B\[[0-9;]*[A-Za-z]", "", s)
+
+    def _display_width(s: str) -> int:
+        s = s.replace("\t", "    ")
+        width = 0
+        for ch in s:
+            if unicodedata.combining(ch):
+                continue
+            ea = unicodedata.east_asian_width(ch)
+            width += 2 if ea in ("W", "F") else 1
+        return width
+
+    # Compute desired inner width: full terminal width when available
+    visible_widths = [_display_width(_strip_ansi(line)) for line in lines]
+    term_width = shutil.get_terminal_size(fallback=(120, 24)).columns
+    # Borders add 4 chars: left '│ ', right ' │'
+    desired_inner = max(20, term_width - 4)
+
+    # If content has lines longer than max_inner, hard-truncate with ellipsis preserving ANSI
+    def _truncate_line(line: str, target: int) -> str:
+        plain = _strip_ansi(line)
+        if _display_width(plain) <= target:
+            return line
+        out = []
+        acc = 0
+        i = 0
+        while i < len(line) and acc < max(0, target - 1):
+            ch = line[i]
+            out.append(ch)
+            # Skip ANSI sequences intact
+            if ch == "\x1b":
+                # consume until letter
+                j = i + 1
+                while j < len(line) and not (line[j].isalpha() and line[j-1] == 'm'):
+                    j += 1
+                # include the terminator if present
+                if j < len(line):
+                    out.append(line[i+1:j+1])
+                    i = j + 1
+                else:
+                    i += 1
+                continue
+            # width accounting
+            if not unicodedata.combining(ch):
+                ea = unicodedata.east_asian_width(ch)
+                acc += 2 if ea in ("W", "F") else 1
+            i += 1
+        return ''.join(out) + '…'
+
+    adjusted_lines = [_truncate_line(line, desired_inner) for line in lines]
+    inner_width = desired_inner
+
+    top = "┌" + "─" * (inner_width + 2) + "┐"
+    bottom = "└" + "─" * (inner_width + 2) + "┘"
+    print(top)
+    for line in adjusted_lines:
+        vis = _strip_ansi(line)
+        pad_len = inner_width - _display_width(vis)
+        pad = NBSP * max(pad_len, 0)
+        print("│ " + line + pad + " │")
+    print(bottom)
+
+
+@contextlib.contextmanager
+def _boxed_capture():
+    global _BOX_CAPTURE_ACTIVE
+    buf = io.StringIO()
+    prev = _BOX_CAPTURE_ACTIVE
+    _BOX_CAPTURE_ACTIVE = True
+    try:
+        with contextlib.redirect_stdout(buf):
+            yield
+    finally:
+        _BOX_CAPTURE_ACTIVE = prev
+        content = buf.getvalue().rstrip("\n")
+        _print_boxed_block(content)
+
+
+def _execute_with_box(shell, cmd_text: str, timeout: int, title_line: str = None, box: bool = True):
+    start_time = time.time()
+    if box and not _BOX_CAPTURE_ACTIVE:
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            if title_line:
+                print(title_line)
+            success, stdout, stderr = shell.execute(cmd_text, timeout=timeout)
+        execution_time = time.time() - start_time
+        content = buf.getvalue().rstrip("\n")
+        _print_boxed_block(content)
+        return success, stdout, stderr, execution_time
+    else:
+        if title_line:
+            print(title_line)
+        success, stdout, stderr = shell.execute(cmd_text, timeout=timeout)
+        execution_time = time.time() - start_time
+        return success, stdout, stderr, execution_time
 
 # Parse command-line arguments
 parser = argparse.ArgumentParser()
@@ -429,151 +534,156 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     if not next_cmd:
                         break
                     
-                    # Print status before executing
-                    cmd_manager.print_status()
-                    
-                    # Periodically analyze and update the command list
-                    if commands_since_analysis >= 3 and cmd_type == 'main':
-                        print("\n🔍 Periodic command list analysis...")
-                        api_key = os.environ.get("OPENAI_API_KEY")
-                        cmd_manager.update_command_list_with_llm(api_key)
-                        commands_since_analysis = 0
-                    
-                    # Execute the command
-                    if cmd_type == 'main':
-                        cmd_text = next_cmd['command']
-                        cmd_index = next_cmd['index']
-                        print(f"📋 Executing main command {cmd_index + 1}/{cmd_manager.total_commands}: {cmd_text}")
+                    # Box everything printed in this iteration into one block
+                    with _boxed_capture():
+                        # Print status before executing
+                        cmd_manager.print_status()
                         
-                        start_time = time.time()
-                        success, stdout, stderr = shell.execute(cmd_text, timeout=100)
-                        execution_time = time.time() - start_time
+                        # Periodically analyze and update the command list
+                        if commands_since_analysis >= 3 and cmd_type == 'main':
+                            print("\n🔍 Periodic command list analysis...")
+                            api_key = os.environ.get("OPENAI_API_KEY")
+                            cmd_manager.update_command_list_with_llm(api_key)
+                            commands_since_analysis = 0
                         
-                        # Check if the command was aborted due to waiting for input and an alternative was suggested
-                        if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
-                            alternative_cmd = shell.suggested_alternative
-                            print(f"🔄 Command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
+                        # Execute the command
+                        if cmd_type == 'main':
+                            cmd_text = next_cmd['command']
+                            cmd_index = next_cmd['index']
+                            success, stdout, stderr, execution_time = _execute_with_box(
+                                shell, cmd_text, timeout=100,
+                                title_line=f"📋 Executing main command {cmd_index + 1}/{cmd_manager.total_commands}: {cmd_text}",
+                                box=False
+                            )
                             
-                            # Add the alternative command with high priority
-                            cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
+                            # Check if the command was aborted due to waiting for input and an alternative was suggested
+                            if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
+                                alternative_cmd = shell.suggested_alternative
+                                print(f"🔄 Command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
+                                
+                                # Add the alternative command with high priority
+                                cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
+                                
+                                # Clear the suggested alternative
+                                shell.suggested_alternative = None
+                            # Check if the command should be removed as suggested by LLM
+                            elif not success and stderr.startswith("Command removed -"):
+                                reason = stderr.replace("Command removed -", "").strip()
+                                print(f"🚫 Removed command as suggested by LLM: {reason}")
+                                # We don't need to do anything else, just mark it as executed and move on
                             
-                            # Clear the suggested alternative
-                            shell.suggested_alternative = None
-                        # Check if the command should be removed as suggested by LLM
-                        elif not success and stderr.startswith("Command removed -"):
-                            reason = stderr.replace("Command removed -", "").strip()
-                            print(f"🚫 Removed command as suggested by LLM: {reason}")
-                            # We don't need to do anything else, just mark it as executed and move on
-                        
-                        # Mark command as executed
-                        cmd_manager.mark_command_executed(
-                            cmd_index, 'main', success, stdout, stderr, execution_time
-                        )
-                        
-                        # Increment counter for periodic analysis
-                        commands_since_analysis += 1
-                        
-                        if not success:
-                            print(f"⚠️ Command failed, attempting LLM debugging...")
+                            # Mark command as executed
+                            cmd_manager.mark_command_executed(
+                                cmd_index, 'main', success, stdout, stderr, execution_time
+                            )
                             
-                            # Call LLM for debugging
-                            try:
-                                current_dir = shell.get_cwd()
-                                
-                                # Use unified LLM debugging function
-                                fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
+                            # Increment counter for periodic analysis
+                            commands_since_analysis += 1
+                            
+                            if not success:
+                                print(f"⚠️ Command failed, attempting LLM debugging...")
                                 
-                                if fix_command:
-                                    # Get the current debug model to show the correct provider name
-                                    from llm_debugging import get_current_debug_model
-                                    current_model = get_current_debug_model()
-                                    print(f"🔧 {current_model.capitalize()} suggested fix command: {fix_command}")
-                                    
-                                    # Add the fix to the command list manager
-                                    fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
-                                    
-                                    # Execute the fix command
-                                    print(f"🔄 Running suggested fix command: {fix_command}")
-                                    fix_start_time = time.time()
-                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=120)
-                                    fix_execution_time = time.time() - fix_start_time
+                                # Call LLM for debugging
+                                try:
+                                    current_dir = shell.get_cwd()
                                     
-                                    # Mark fix command as executed
-                                    cmd_manager.mark_command_executed(
-                                        fix_index, 'fix', fix_success, fix_stdout, fix_stderr, fix_execution_time
-                                    )
+                                    # Use unified LLM debugging function
+                                    fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
                                     
-                                    if fix_success:
-                                        print(f"✅ Fix command succeeded")
+                                    if fix_command:
+                                        # Get the current debug model to show the correct provider name
+                                        from llm_debugging import get_current_debug_model
+                                        current_model = get_current_debug_model()
+                                        print(f"🔧 {current_model.capitalize()} suggested fix command: {fix_command}")
+                                        
+                                        # Add the fix to the command list manager
+                                        fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
                                         
-                                        # Check if we should skip the original command
-                                        api_key = os.environ.get("OPENAI_API_KEY")
-                                        should_skip, skip_reason = cmd_manager.should_skip_original_command(
-                                            cmd_text, fix_command, fix_stdout, fix_stderr, api_key
+                                        # Execute the fix command
+                                        fix_success, fix_stdout, fix_stderr, fix_execution_time = _execute_with_box(
+                                            shell, fix_command, timeout=120,
+                                            title_line=f"🔧 Executing suggested fix: {fix_command}",
+                                            box=False
                                         )
                                         
-                                        if should_skip:
-                                            print(f"🔄 Skipping original command: {skip_reason}")
-                                            
-                                            # Mark the original command as successful without running it
-                                            cmd_manager.mark_command_executed(
-                                                cmd_index, 'main', True, 
-                                                f"Command skipped after successful fix: {skip_reason}", 
-                                                "", time.time() - start_time
-                                            )
-                                            
-                                            print(f"✅ Original command marked as successful (skipped)")
-                                            
-                                            # After a successful fix and skipping the original command,
-                                            # analyze and update the entire command list
-                                            print("\n🔍 Analyzing and updating remaining commands based on fix results...")
-                                            cmd_manager.update_command_list_with_llm(api_key)
-                                        else:
-                                            # Retry the original command
-                                            print(f"🔄 Retrying original command: {cmd_text}")
-                                            retry_start_time = time.time()
-                                            retry_success, retry_stdout, retry_stderr = shell.execute(cmd_text, timeout=100)
-                                            retry_execution_time = time.time() - retry_start_time
+                                        # Mark fix command as executed
+                                        cmd_manager.mark_command_executed(
+                                            fix_index, 'fix', fix_success, fix_stdout, fix_stderr, fix_execution_time
+                                        )
+                                        
+                                        if fix_success:
+                                            print(f"✅ Fix command succeeded")
                                             
-                                            # Update the original command status
-                                            cmd_manager.mark_command_executed(
-                                                cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                            # Check if we should skip the original command
+                                            api_key = os.environ.get("OPENAI_API_KEY")
+                                            should_skip, skip_reason = cmd_manager.should_skip_original_command(
+                                                cmd_text, fix_command, fix_stdout, fix_stderr, api_key
                                             )
                                             
-                                            if retry_success:
-                                                print(f"✅ Original command succeeded after fix!")
+                                            if should_skip:
+                                                print(f"🔄 Skipping original command: {skip_reason}")
                                                 
-                                                # After a successful fix and successful retry,
+                                                # Mark the original command as successful without running it
+                                                cmd_manager.mark_command_executed(
+                                                    cmd_index, 'main', True, 
+                                                    f"Command skipped after successful fix: {skip_reason}", 
+                                                    "", execution_time
+                                                )
+                                                
+                                                print(f"✅ Original command marked as successful (skipped)")
+                                                
+                                                # After a successful fix and skipping the original command,
                                                 # analyze and update the entire command list
                                                 print("\n🔍 Analyzing and updating remaining commands based on fix results...")
                                                 cmd_manager.update_command_list_with_llm(api_key)
                                             else:
-                                                print(f"⚠️ Original command still failed after fix, continuing...")
+                                                # Retry the original command
+                                                print(f"🔄 Retrying original command: {cmd_text}")
+                                                retry_success, retry_stdout, retry_stderr, retry_execution_time = _execute_with_box(
+                                                    shell, cmd_text, timeout=100,
+                                                    title_line=f"🔄 Retrying command: {cmd_text}",
+                                                    box=False
+                                                )
+                                                
+                                                # Update the original command status
+                                                cmd_manager.mark_command_executed(
+                                                    cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                                )
+                                                
+                                                if retry_success:
+                                                    print(f"✅ Original command succeeded after fix!")
+                                                    
+                                                    # After a successful fix and successful retry,
+                                                    # analyze and update the entire command list
+                                                    print("\n🔍 Analyzing and updating remaining commands based on fix results...")
+                                                    cmd_manager.update_command_list_with_llm(api_key)
+                                                else:
+                                                    print(f"⚠️ Original command still failed after fix, continuing...")
+                                        else:
+                                            print(f"❌ Fix command failed: {fix_stderr}")
+                                            print(f"⚠️ First fix attempt failed; continuing without web search...")
+                                            
+                                            # No web-search retry; continue
+                                            print(f"⚠️ Continuing with remaining commands...")
                                     else:
-                                        print(f"❌ Fix command failed: {fix_stderr}")
-                                        print(f"⚠️ First fix attempt failed; continuing without web search...")
-                                        
-                                        # No web-search retry; continue
+                                        # Get the current debug model to show the correct provider name
+                                        from llm_debugging import get_current_debug_model
+                                        current_model = get_current_debug_model()
+                                        print(f"❌ No fix suggested by {current_model.capitalize()}")
                                         print(f"⚠️ Continuing with remaining commands...")
-                                else:
-                                    # Get the current debug model to show the correct provider name
-                                    from llm_debugging import get_current_debug_model
-                                    current_model = get_current_debug_model()
-                                    print(f"❌ No fix suggested by {current_model.capitalize()}")
+                                        
+                                except Exception as debug_e:
+                                    print(f"❌ LLM debugging failed: {debug_e}")
                                     print(f"⚠️ Continuing with remaining commands...")
-                                    
-                            except Exception as debug_e:
-                                print(f"❌ LLM debugging failed: {debug_e}")
-                                print(f"⚠️ Continuing with remaining commands...")
                     
-                    elif cmd_type == 'fix':
-                        cmd_text = next_cmd['fix_command']
-                        cmd_index = next_cmd['index']
-                        print(f"🔧 Executing fix command {cmd_index + 1}: {cmd_text}")
-                        
-                        start_time = time.time()
-                        success, stdout, stderr = shell.execute(cmd_text, timeout=100)
-                        execution_time = time.time() - start_time
+                            elif cmd_type == 'fix':
+                                cmd_text = next_cmd['fix_command']
+                                cmd_index = next_cmd['index']
+                                success, stdout, stderr, execution_time = _execute_with_box(
+                                    shell, cmd_text, timeout=100,
+                                    title_line=f"🔧 Executing fix command {cmd_index + 1}: {cmd_text}",
+                                    box=False
+                                )
                         
                         # Check if the fix command was aborted due to waiting for input and an alternative was suggested
                         if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
@@ -617,11 +727,11 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                         for fix_index in additional_fixes:
                             fix_cmd = cmd_manager.suggested_fixes[fix_index]
                             cmd_text = fix_cmd['fix_command']
-                            print(f"🔧 Executing additional fix: {cmd_text}")
-                            
-                            start_time = time.time()
-                            success, stdout, stderr = shell.execute(cmd_text, timeout=100)
-                            execution_time = time.time() - start_time
+                            success, stdout, stderr, execution_time = _execute_with_box(
+                                shell, cmd_text, timeout=100,
+                                title_line=f"🔧 Executing additional fix: {cmd_text}",
+                                box=False
+                            )
                             
                             # Check if the fix command was aborted due to waiting for input and an alternative was suggested
                             if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative: