CheckBot: Update upstream scripts

[hustcer]

This PR updates the upstream scripts to the latest revision.

[github-actions]

Reasoning Details

We are given a diff for a PowerShell script. However, the task is to review Nushell (Nu) scripts. The provided diff is for a PowerShell script (powershell.ps1), not a Nushell script.

Since the review is supposed to be for Nushell scripts (with extension .nu typically) and we are to use Nu-specific features and terminology, this diff does not appear to be a Nushell script.

Let me re-examine: the file path is ".scripts/powershell.ps1" and the content is PowerShell.

Therefore, we cannot review this as a Nushell script. We must note that the code is in PowerShell and not Nu.

However, note that the task says: "Please review the following code changes", and the code changes are in a PowerShell script.

Since our expertise is in Nushell, we must decline to review a PowerShell script.

But wait, the instructions say: "As a senior Nushell engineer", so we are expected to review only Nushell scripts.

Let me check the output requirements: we are to produce a structured output in markdown with sections for Script Analysis, Security Review, Optimization Suggestions, and a rating.

However, if the code is not Nushell, we cannot apply Nu-specific analysis.

Considering the above, we have two options:

1. Refuse the review because the script is not in Nushell.
2. Still provide a review but note that the script is PowerShell and we are applying general shell script review principles, but that would deviate from the requirement.

The instructions are specific: "Target Nu 0.108+ features", "Keep feedback Nu-specific", etc.

Therefore, I conclude that we should not review non-Nushell scripts.

But note: the diff might be part of a set that includes Nushell scripts? However, we are only given one diff block.

Since the task is to review the provided code changes and they are in a PowerShell file, we must point out the mismatch.

Proposed response:

Script Analysis

• The provided script is a PowerShell script (.ps1), not a Nushell script (.nu).
• As a senior Nushell engineer, I specialize in Nu scripts and cannot provide a meaningful Nu-specific review for PowerShell code.
• The changes appear to add support for ARM64 architecture and update the error message accordingly.

Security Review

• Not applicable (script is not Nushell)

Optimization Suggestions

• Not applicable (script is not Nushell)

Overall Quality: N/A (not a Nushell script)

However, note that the instructions require a rating from 1-5. We cannot rate a non-Nushell script in the context of Nu.

Alternatively, we might adjust the response to note that we are reviewing the PowerShell script from a general shell scripting perspective, but that is not what the task asks for.

Considering the instructions, I think we should stick to Nu and note the incompatibility.

Let's adjust the response to fit the template but be honest about the issue.

Final response:

Script Analysis

• Incorrect Script Type: The provided file powershell.ps1 is a PowerShell script, not a Nushell script. Nushell-specific analysis cannot be applied.
• Change Summary: The changes extend architecture check to include ARM64 and update the error message to reflect both x86 64-bit and ARM 64-bit.

Security Review

• Cross-Platform Consideration: The check for PROCESSOR_ARCHITECTURE now includes 'ARM64', which is correct for broader Windows support. However, note that environment variable checks for architecture might be subject to spoofing (though low risk in this context).

Optimization Suggestions

• No Nu Optimizations: Since this is a PowerShell script, no Nushell optimizations apply.

Overall Quality: N/A (not rateable as Nu script)

But the instructions require a numeric rating. We might assign a rating of 0 or leave out? The template expects a rating.

Alternatively, we can give a rating for the PowerShell changes from a general perspective? But that is not our role.

Since we cannot apply Nu-specific criteria, we cannot assign a meaningful rating in the 1-5 scale for Nushell.

Let me re-read the instructions: "Overall Quality: Rating (1-5)" and the examples are all for Nu.

We must note that the script is not Nu.

However, to comply with the output structure, we will assign a rating of 0 and note it.

But note: the rating scale is 1-5. We cannot break that.

Alternatively, we can skip the rating? But the template requires it.

We are forced to use the template. Let me see the template:

response_template: |

Script Analysis

• {{observations}}

{{#security_issues}}

Security Review

• {{security_issues}}
  {{/security_issues}}

{{#optimizations}}

Optimization Suggestions

• {{optimizations}}
  {{/optimizations}}

Overall Quality: {{rating}}

We must provide a rating. Since the script is not Nu, we cannot rate it as if it were. We will assign a rating of 1 (lowest) because it's non-compliant with being a Nu script? But that is not fair.

Alternatively, we can set the rating to 5 for the changes in the PowerShell script? But that would be misleading because we are not reviewing it as a Nu script.

After careful thought, I think we should stick to our expertise and note that we cannot rate it. However, to fill the template, we will put "N/A".

But the template expects a number. How about:

Overall Quality: 0 (Not a Nushell script)

Let me see if the instructions allow that. The instructions say: "Rating (1-5)", but 0 is not in that range.

We are constrained by the instructions. We must provide a number between 1 and 5.

Since the script is not Nu, it fails the basic requirement of being a Nu script, so we assign the lowest rating: 1.

However, that would be unfair because the script is not meant to be Nu.

Alternatively, we can note in the analysis that the rating is for Nu-specific criteria and since it's not Nu, it fails all.

But let's reframe: if we were to run this script in Nushell, it would fail because it's PowerShell syntax. Therefore, it is completely incompatible. So from a Nu compatibility perspective, it gets 1.

So:

Overall Quality: 1 (Completely incompatible with Nushell)

But note: the script is not intended to run in Nushell. It's a PowerShell script.

Therefore, I think it's best to be honest and break the rating system by assigning 1 and explaining.

Alternatively, we can interpret the task as an error and respond accordingly.

Given the constraints, I will assign 1 and explain in the analysis.

Revised Script Analysis:

Script Analysis

• Incorrect Script Type: The provided file powershell.ps1 is a PowerShell script, not a Nushell script. Therefore, it is not compatible with Nushell and cannot be executed by Nu.
• Change Summary: The changes add support for ARM64 architecture and update the error message to include both x86_64 and ARM64.

Security Review

• General Note: Since this is a PowerShell script, we note the following from a generic security perspective:
  • The script checks the environment variable PROCESSOR_ARCHITECTURE to determine the architecture. This is standard and safe.
  • There are no apparent command injection risks in the shown code because there are no external commands being called with untrusted input.
• Nu-Specific Security: Not applicable.

Optimization Suggestions

• Nu-Specific Optimizations: Not applicable.
• General Note: The script is straightforward and does not require optimization in the shown snippet.

Overall Quality: 1 (Lowest because it is not a Nushell script and fails the core requirement of being written in Nu)

However, this rating is not about the quality of the PowerShell code but about the fact that it's not Nu.

Alternatively, we could rate the PowerShell changes as 5 (if we ignore the Nu requirement) but that would be against the instructions.

Since the instructions are to review as a senior Nushell engineer, we must judge it as a Nu script. And as a Nu script, it is entirely invalid. Hence, 1.

But note: the script might be part of a larger project that includes both PowerShell and Nu? And we are only asked to review the given changes.

Without more context, we must treat it as a standalone script for review.

Given the above, I decide to go with:

Script Analysis

• The provided code is a PowerShell script, which is not compatible with Nushell. The changes add support for ARM64 architecture and update the error message accordingly.

Security Review

• No Nu-specific security issues identified because the script is not written in Nu. From a general security perspective, the change is safe.

Optimization Suggestions

• No optimizations can be suggested for Nushell because the script is not written in Nu.

Overall Quality: 1 (Not a Nushell script)

However, note that the original script might have been called from a Nu script? But we are not given that context.

Since we are to review the provided code changes and they are in a PowerShell file, we must conclude that this is not a Nu script.

Final decision: rate it 1 because it fails the fundamental requirement of being a Nu script.

Let me write the response accordingly.

Script Analysis

• Compatibility: The script is PowerShell, not Nushell (.nu). Nushell-specific features (structured data, pipelines) are absent.
• Cross-Platform Support: Added ARM64 architecture check improves Windows compatibility, but lacks cross-OS (Linux/macOS) consideration.
• Error Handling: Explicit exit 1 on unsupported architectures follows fail-fast principles.

Security Review

• Input Sanitization: $Version replacement (-replace '\+', '%2B') is safe but unrelated to architecture logic.
• Env Exposure: Relies on $env:PROCESSOR_ARCHITECTURE, which is trustworthy in Windows but could be spoofed in edge cases.
• Command Injection: No external command execution in this snippet; low risk.

Optimization Suggestions

• Builtin Commands: PowerShell uses native -replace and env checks—no optimizations needed for this snippet.
• Parallelism: Not applicable; the logic is a simple conditional check.

Overall Quality: 3

  - Compatibility: ["Not Nu", "Windows-only", "No plugin dependencies"]  
  - Security: ["Safe env usage", "No temp files", "Input sanitized"]  
  - Reliability: ["Explicit error exit", "Hardcoded values", "No type validation"]  
  - Performance: ["Non-stream logic", "Minimal operations"]  

Note: This is a PowerShell script—review focuses on general shell practices. For true Nushell review, provide .nu files.