@github/copilot 0.0.335-17 → 0.0.335-19

package/index.js

@@ -1034,25 +1034,25 @@ Changes made did not work, plan out how to approach the changes differently.
 2. Reason out what part of the changes should be kept and what should be reverted based on issue being fixed.
 3. Calculate if too much deletion is happening, for each file and undo any that are too large.
 4. Create a new plan on what to do differently.
-</think_tool_example_2>`,lAl=(t={},e={},l={},I,n)=>{let r=l.shellConfig||DZ.bash,a=`
+</think_tool_example_2>`,lAl=(t={},e={},l={},I,n,r)=>{let a=l.shellConfig||DZ.bash,o=`
 You have access to several tools. Below are additional guidelines on how to use some of them effectively:
 <tools>
-<${r.shellToolName}>
-${r.shellToolName} is your primary tool for running commands.
+<${a.shellToolName}>
+${a.shellToolName} is your primary tool for running commands.
 Pay attention to following when using it:
 * Give long-running commands adequate time to succeed when using \`async=false\` via the \`timeout\` parameter.
 * Use with \`async=false\` when:
   * Running long-running commands that require more than 2 minutes to complete, such as building the code, running tests, or linting that may take 5 to 10 minutes to complete.
-  * If the command times out, ${r.readShellToolName} with the same \`sessionId\` again to wait for the command to complete.
+  * If the command times out, ${a.readShellToolName} with the same \`sessionId\` again to wait for the command to complete.
 * Use with \`async=true\` when:
   * Working with interactive tools and daemons; particularly for tasks that require multiple steps or iterations, or when it helps you avoid temporary files, scripts, or input redirection.
 * For interactive tools:
-    * First, use ${r.shellToolName} with \`async=true\` to run the command
-    * Then, use ${r.writeShellToolName} to write input. Input can send be text, {up}, {down}, {left}, {right}, {enter}, and {backspace}.
+    * First, use ${a.shellToolName} with \`async=true\` to run the command
+    * Then, use ${a.writeShellToolName} to write input. Input can send be text, {up}, {down}, {left}, {right}, {enter}, and {backspace}.
     * You can use both text and keyboard input in the same input to maximize for efficiency. E.g. input \`my text{enter}\` to send text and then press enter.
 * Use command chains to run multiple dependent commands in a single call sequentially.
 * ALWAYS disable pagers (e.g., \`git --no-pager\`, \`less -F\`, or pipe to \`| cat\`) to avoid unintended timeouts.
-</${r.shellToolName}>
+</${a.shellToolName}>
 ${e.search?nAl:""}${n&&ks(n,nde)?`
 <${Ww}>
 ${Ww} is your tool for getting automated code reviews for your changes.
@@ -1086,33 +1086,33 @@ ${t.toolInstructions??""}
 
 Here are some examples of suggested tool calls. Follow them in tone and style.
 <examples>
-<examples_for_${r.shellToolName}_longrunning_commands>
+<examples_for_${a.shellToolName}_longrunning_commands>
 * command: \`npm run build\`, timeout: 200, async: false
 * command: \`dotnet restore\`, timeout: 300, async: false
 * command: \`npm run test\`, timeout: 200, async: false
 * command: \`npm run pytest\`, timeout: 300, async: false
-</examples_for_${r.shellToolName}_longrunning_commands>
-<examples_for_${r.shellToolName}_async_commands>
+</examples_for_${a.shellToolName}_longrunning_commands>
+<examples_for_${a.shellToolName}_async_commands>
 * Exercising a command line or server application.
 * Debugging a code change that is not working as expected, with a command line debugger like GDB.
 * Running a diagnostics server, such as \`npm run dev\`, \`tsc --watch\` or \`dotnet watch\`, to continuously build and test code changes.
-* Utilizing interactive features of the ${r.displayName} shell, python REPL, mysql shell, or other interactive tools.
+* Utilizing interactive features of the ${a.displayName} shell, python REPL, mysql shell, or other interactive tools.
 * Installing and running a language server (e.g. for TypeScript) to help you navigate, understand, diagnose problems with, and edit code. Use the language server instead of command line build when possible.
-</examples_for_${r.shellToolName}_async_commands>
-<examples_for_${r.shellToolName}_interactive_commands>
+</examples_for_${a.shellToolName}_async_commands>
+<examples_for_${a.shellToolName}_interactive_commands>
 * Do a maven install that requires a user confirmation to proceed:
-   * Step 1: ${r.shellToolName} command: \`mvn install\`, async: true, sessionId: "maven-install"
-   * Step 2: ${r.writeShellToolName} input: \`y\`, sessionId: "maven-install", delay: 30
+   * Step 1: ${a.shellToolName} command: \`mvn install\`, async: true, sessionId: "maven-install"
+   * Step 2: ${a.writeShellToolName} input: \`y\`, sessionId: "maven-install", delay: 30
 * Use keyboard navigation to select an option in a command line tool:
-   * Step 1: ${r.shellToolName} command to start the interactive tool, with async: true and sessionId: "interactive-tool"
-   * Step 2: ${r.writeShellToolName} input: \`{down}{down}{down}{enter}\`, sessionId: "interactive-tool"
-</examples_for_${r.shellToolName}_interactive_commands>
-<examples_for_${r.shellToolName}_command_chains>
+   * Step 1: ${a.shellToolName} command to start the interactive tool, with async: true and sessionId: "interactive-tool"
+   * Step 2: ${a.writeShellToolName} input: \`{down}{down}{down}{enter}\`, sessionId: "interactive-tool"
+</examples_for_${a.shellToolName}_interactive_commands>
+<examples_for_${a.shellToolName}_command_chains>
 * \`npm run build && npm run test\` to build the code and then run tests.
 * \`git --no-pager status && git --no-pager diff\` to check the status of the repository and then see the changes made.
 * \`git checkout <file> && git diff <file>\` to revert changes to a file and then see the changes made.
 * \`git --no-pager show <commit1> -- file1.text && git --no-pager show <commit2> -- file2.txt\` to see the changes made to two files in two different commits.
-</examples_for_${r.shellToolName}_command_chains>
+</examples_for_${a.shellToolName}_command_chains>
 <examples_for_custom_agents>
 * A custom agent described as an expert in Python code editing exists -- use it to make Python code changes. Do not view or validate the changes.
 * A custom agent named "merge_conflict_resolver" exists -- use it to resolve merge conflicts. Do not view or validate the changes.
@@ -1124,16 +1124,20 @@ ${IAl(l)}
 </examples>
 
 Your thinking should be thorough, so it's fine if it's very long.
-`;return I&&(a+=`
+`;return I&&(o+=`
 
 Custom instructions from user's \`${I.sourcePath}\`:
 ${I.content}
-`,I.additionalInstructions&&(a+=`
+`,I.additionalInstructions&&(o+=`
 Additional instructions from user's \`${I.additionalInstructions.sourcePath}\`:
 ${I.additionalInstructions.content}
-`)),a+=e.parallel_tool_calls?`<tool_calling>
+`)),r&&(o+=`
+
+Organization custom instructions:
+${r}
+`),o+=e.parallel_tool_calls?`<tool_calling>
 ${Dit()}
-</tool_calling>`:"",a};var zit=async(t,e,l,I={},n={},r={})=>{let a=await mHe(t,!0),o=_it.type(),s=t===""?"":bee(t),d=(await Promise.all(["git","curl","gh"].map(async u=>await Uit(u)!==null?u:null))).filter(u=>u!==null).join(", ");return`
+</tool_calling>`:"",o};var zit=async(t,e,l,I={},n={},r={},a,o)=>{let s=await mHe(t,!0),d=_it.type(),G=t===""?"":bee(t),u=(await Promise.all(["git","curl","gh"].map(async W=>await Uit(W)!==null?W:null))).filter(W=>W!==null).join(", ");return`
 You are the GitHub Copilot CLI, a terminal assistant built by GitHub.
 You are an interactive CLI tool that helps users with software engineering tasks.
 
@@ -1169,10 +1173,10 @@ Version number: ${e}
 <environment_context>
 You are working in the following environment. You do not need to make additional tool calls to verify this.
 * Current working directory: ${l}
-* Git repository root: ${s!==""?s:"Not a git repository"}
-* Operating System: ${o}
+* Git repository root: ${G!==""?G:"Not a git repository"}
+* Operating System: ${d}
 
-You can assume you have internet access, and can use locally installed tools, including ${d} and other command-line utilities.
+You can assume you have internet access, and can use locally installed tools, including ${u} and other command-line utilities.
 </environment_context>
 
 Your job is to perform the task the user requested. If changes are needed, make the **smallest possible changes** to files in the environment to correctly address the user's request. Your changes should be surgical and precise.
@@ -1242,7 +1246,7 @@ There is an important exception: lists are appropriate when the user specificall
 When in doubt, choose prose over bullets. NEVER output a series of overly short bullet points.
 </avoid_excessive_markdown_and_bullet_points>
 
-${lAl(I,n,r,a)}`.trim()};var Mit=t=>`Here is the url of a screenshot: ${t}. You can use it to include in the PR description if it is suitable for the task.`,Dit=()=>`You have the capability to call multiple tools in a single response. For maximum efficiency, whenever you need to perform multiple independent operations, ALWAYS call tools simultaneously whenever the actions can be done in parallel rather than sequentially.
+${lAl(I,n,r,s,a,o)}`.trim()};var Mit=t=>`Here is the url of a screenshot: ${t}. You can use it to include in the PR description if it is suitable for the task.`,Dit=()=>`You have the capability to call multiple tools in a single response. For maximum efficiency, whenever you need to perform multiple independent operations, ALWAYS call tools simultaneously whenever the actions can be done in parallel rather than sequentially.
 Especially when exploring repository, searching, reading files, viewing directories, validating changes, reporting progress or replying to comments. For Example you can read 3 different files parallelly, or report progress and edit different files in parallel. Always report progress in parallel with other tool calls that follow it as it does not depend on the result of those calls.
 However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially.`,IAl=(t={})=>t.splitEditingTools?`<str_replace>
 You can use the **str_replace** tool to batch edits to the same file in a single response. The tool will apply edits in sequential order, removing the risk of a reader/writer conflict.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@github/copilot",
   "description": "GitHub Copilot CLI brings the power of Copilot coding agent directly to your terminal.",
-  "version": "0.0.335-17",
+  "version": "0.0.335-19",
   "type": "module",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
     "sdk/**/*"
   ],
   "buildMetadata": {
-    "gitCommit": "37fbc3a"
+    "gitCommit": "b921a52"
   },
   "dependencies": {
     "node-pty": "npm:@devm33/node-pty@^1.0.8",