@polka-codes/cli 0.8.3 → 0.8.5

package/dist/index.js

@@ -31550,7 +31550,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.8.3";
+var version = "0.8.5";
 
 // ../core/src/AiService/AiServiceBase.ts
 class AiServiceBase {
@@ -40930,10 +40930,16 @@ ${search}`);
 };
 // ../core/src/tools/utils/getArg.ts
 var getString = (args2, name2, defaultValue) => {
+  if (typeof args2 !== "object" || Array.isArray(args2)) {
+    throw new Error(`Invalid argument type: ${name2} ${args2}`);
+  }
   const ret = args2[name2] ?? defaultValue;
   if (ret === undefined) {
     throw new Error(`Missing required argument: ${name2}`);
   }
+  if (typeof ret !== "string") {
+    throw new Error(`Invalid argument type: ${name2} ${ret}`);
+  }
   return ret;
 };
 var getStringArray = (args2, name2, defaultValue) => {
@@ -40947,6 +40953,9 @@ var getStringArray = (args2, name2, defaultValue) => {
   if (ret === "") {
     return [];
   }
+  if (typeof ret !== "string") {
+    throw new Error(`Invalid argument type: ${name2} ${ret}`);
+  }
   return ret.split(",").map((s2) => s2.trim());
 };
 var getBoolean = (args2, name2, defaultValue) => {
@@ -40957,13 +40966,16 @@ var getBoolean = (args2, name2, defaultValue) => {
     }
     return defaultValue;
   }
+  if (typeof ret !== "string") {
+    throw new Error(`Invalid argument type: ${name2} ${ret}`);
+  }
   switch (ret.toLowerCase()) {
     case "true":
       return true;
     case "false":
       return false;
     default:
-      throw new Error(`Invalid argument value: ${name2}`);
+      throw new Error(`Invalid argument value: ${name2} ${ret}`);
   }
 };
 var getInt = (args2, name2, defaultValue) => {
@@ -40974,50 +40986,104 @@ var getInt = (args2, name2, defaultValue) => {
     }
     return defaultValue;
   }
+  if (typeof ret !== "string") {
+    throw new Error(`Invalid argument type: ${name2} ${ret}`);
+  }
   const parsed = Number.parseInt(ret);
   if (Number.isNaN(parsed)) {
-    throw new Error(`Invalid argument value: ${name2}`);
+    throw new Error(`Invalid argument value: ${name2} ${ret}`);
   }
   return parsed;
 };
+var getArray = (args2, name2, defaultValue) => {
+  if (typeof args2 !== "object" || Array.isArray(args2)) {
+    throw new Error(`Invalid argument type: ${name2} ${args2}`);
+  }
+  const ret = args2[name2];
+  if (ret === undefined) {
+    if (defaultValue === undefined) {
+      throw new Error(`Missing required argument: ${name2}`);
+    }
+    return defaultValue;
+  }
+  if (Array.isArray(ret)) {
+    return ret;
+  }
+  return [ret];
+};
 // ../core/src/tools/askFollowupQuestion.ts
 var toolInfo = {
   name: "ask_followup_question",
-  description: "Whenever you need extra details or clarification to complete the task, pose a direct question to the user. Use this tool sparingly to avoid excessive back-and-forth. If helpful, offer multiple-choice options or examples to guide the user’s response.",
+  description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.",
   parameters: [
     {
-      name: "question",
-      description: "The question to ask the user. This should be a clear, specific question that addresses the information you need.",
+      name: "questions",
+      description: "One or more follow-up questions you need answered before you can continue.",
       required: true,
-      usageValue: "Your question here"
-    },
-    {
-      name: "options",
-      description: "A comma separated list of possible answers to the question. Ordered by preference. If not provided, the user will be prompted to provide an answer.",
-      required: false,
-      usageValue: "A comma separated list of possible answers (optional)"
+      allowMultiple: true,
+      children: [
+        {
+          name: "prompt",
+          description: "The text of the question.",
+          required: true,
+          usageValue: "question text here"
+        },
+        {
+          name: "options",
+          description: "Ordered list of suggested answers (omit if none).",
+          required: false,
+          allowMultiple: true,
+          usageValue: "suggested answer here"
+        }
+      ]
     }
   ],
   examples: [
     {
-      description: "Request to ask a question",
+      description: "Single clarifying question (no options)",
       parameters: [
         {
-          name: "question",
-          value: "What is the name of the project?"
+          name: "questions",
+          value: { prompt: "What is the target deployment environment?" }
         }
       ]
     },
     {
-      description: "Request to ask a question with options",
+      description: "Single question with multiple-choice options",
       parameters: [
         {
-          name: "question",
-          value: "What framework do you use?"
-        },
+          name: "questions",
+          value: {
+            prompt: "Which frontend framework are you using?",
+            options: ["React", "Angular", "Vue", "Svelte"]
+          }
+        }
+      ]
+    },
+    {
+      description: "Two related questions in one call",
+      parameters: [
         {
-          name: "options",
-          value: "React,Angular,Vue,Svelte"
+          name: "questions",
+          value: [
+            { prompt: "What type of application are you building?" },
+            {
+              prompt: "Preferred programming language?",
+              options: ["JavaScript", "TypeScript", "Python", "Java"]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      description: "Binary (yes/no) confirmation",
+      parameters: [
+        {
+          name: "questions",
+          value: {
+            prompt: "Is it acceptable to refactor existing tests to improve performance?",
+            options: ["Yes", "No"]
+          }
         }
       ]
     }
@@ -41031,13 +41097,26 @@ var handler = async (provider, args2) => {
       message: "Not possible to ask followup question. Abort."
     };
   }
-  const question = getString(args2, "question");
-  const options = getStringArray(args2, "options", []);
-  const answer = await provider.askFollowupQuestion(question, options);
+  const questions = getArray(args2, "questions");
+  if (!questions || questions.length === 0) {
+    return {
+      type: "Error" /* Error */,
+      message: "No questions provided"
+    };
+  }
+  const answers = [];
+  for (const question of questions) {
+    const prompt = getString(question, "prompt");
+    const options = getArray(question, "options", []);
+    const answer = await provider.askFollowupQuestion(prompt, options);
+    answers.push(`<ask_followup_question_answer question="${prompt}">
+${answer}
+</ask_followup_question_answer>`);
+  }
   return {
     type: "Reply" /* Reply */,
-    message: `<ask_followup_question_question>${question}</ask_followup_question_question>
-<ask_followup_question_answer>${answer}</ask_followup_question_answer>`
+    message: answers.join(`
+`)
   };
 };
 var isAvailable = (provider) => {
@@ -41174,33 +41253,27 @@ var delegate_default = {
 // ../core/src/tools/executeCommand.ts
 var toolInfo4 = {
   name: "execute_command",
-  description: `Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will also be executed in the project root directory regardless of executed commands in previous tool uses.`,
+  description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. After an `execute_command` call, no other tool calls are allowed in the same assistant response.",
   parameters: [
     {
       name: "command",
-      description: "The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.",
+      description: "The exact command to run (valid for the current OS). It must be correctly formatted and free of harmful instructions.",
       required: true,
-      usageValue: "Your command here"
+      usageValue: "your-command-here"
     },
     {
       name: "requires_approval",
-      description: `A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.`,
+      description: "Set to `true` for commands that install/uninstall software, modify or delete files, change system settings, perform network operations, or have other side effects. Use `false` for safe, read-only, or purely local development actions (e.g., listing files, make a build, running tests).",
       required: false,
-      usageValue: "true or false"
+      usageValue: "true | false"
     }
   ],
   examples: [
     {
-      description: "Request to execute a command",
+      description: "Make a build",
       parameters: [
-        {
-          name: "command",
-          value: "npm run dev"
-        },
-        {
-          name: "requires_approval",
-          value: "false"
-        }
+        { name: "command", value: "npm run build" },
+        { name: "requires_approval", value: "false" }
       ]
     }
   ],
@@ -42162,6 +42235,23 @@ var getAvailableTools = ({
 };
 
 // ../core/src/Agent/parseAssistantMessage.ts
+function parseNestedParameters(content, parameterPrefix) {
+  const result = {};
+  const nestedParamRegex = new RegExp(`<${parameterPrefix}([^>]+)>([\\s\\S]*?)<\\/${parameterPrefix}\\1>`, "gs");
+  while (true) {
+    const match = nestedParamRegex.exec(content);
+    if (match === null)
+      break;
+    const paramName = match[1];
+    const paramContent = match[2].trim();
+    if (paramContent.includes(`<${parameterPrefix}`)) {
+      result[paramName] = parseNestedParameters(paramContent, parameterPrefix);
+    } else {
+      result[paramName] = paramContent;
+    }
+  }
+  return result;
+}
 function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
   const parameterPrefix = `${toolNamePrefix}parameter_`;
   const results = [];
@@ -42190,10 +42280,25 @@ function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
       for (const param of tool.parameters) {
         const paramName = `${parameterPrefix}${param.name}`;
         const escapedParamName = paramName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const paramPattern = `<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`;
-        const paramMatch = fullTagContent.match(new RegExp(paramPattern, "s"));
-        if (paramMatch) {
-          params[param.name] = paramMatch[1].trim();
+        const paramRegex = new RegExp(`<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`, "gs");
+        const paramMatches = [];
+        while (true) {
+          const paramMatch = paramRegex.exec(fullTagContent);
+          if (paramMatch === null)
+            break;
+          paramMatches.push(paramMatch[1].trim());
+        }
+        if (paramMatches.length > 0) {
+          if (paramMatches.length === 1) {
+            const paramContent = paramMatches[0];
+            if (paramContent.includes(`<${parameterPrefix}`)) {
+              params[param.name] = parseNestedParameters(paramContent, parameterPrefix);
+            } else {
+              params[param.name] = paramContent;
+            }
+          } else {
+            params[param.name] = paramMatches;
+          }
         }
       }
       results.push({
@@ -42225,6 +42330,20 @@ function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
 }
 
 // ../core/src/Agent/prompts.ts
+var renderParameterValue = (key, value, parameterPrefix) => {
+  if (typeof value === "string") {
+    return `<${parameterPrefix}${key}>${value}</${parameterPrefix}${key}>`;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v2) => renderParameterValue(key, v2, parameterPrefix)).join(`
+`);
+  }
+  const inner = Object.entries(value).map(([key2, v2]) => renderParameterValue(key2, v2, parameterPrefix)).join(`
+`);
+  return `<${parameterPrefix}${key}>
+${inner}
+</${parameterPrefix}${key}>`;
+};
 var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
 ## ${toolNamePrefix}${tool.name}
 
@@ -42239,11 +42358,11 @@ Usage:
 ${tool.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
 `)}
 </${toolNamePrefix}${tool.name}>`;
-var toolInfoExamplesPrompt = (idx, tool, example, toolNamePrefix, parameterPrefix) => `
-## Example ${idx + 1}: ${example.description}
+var toolInfoExamplesPrompt = (tool, example, toolNamePrefix, parameterPrefix) => `
+## Example: ${example.description}
 
 <${toolNamePrefix}${tool.name}>
-${example.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.value}</${parameterPrefix}${param.name}>`).join(`
+${example.parameters.map((param) => `${renderParameterValue(param.name, param.value, parameterPrefix)}`).join(`
 `)}
 </${toolNamePrefix}${tool.name}>
 `;
@@ -42252,7 +42371,6 @@ var toolUsePrompt = (tools, toolNamePrefix) => {
     return "";
   }
   const parameterPrefix = `${toolNamePrefix}parameter_`;
-  let exampleIndex = 0;
   return `
 ====
 
@@ -42270,11 +42388,39 @@ Tool use is formatted using XML-style tags. The tool name is enclosed in opening
 ...
 </${toolNamePrefix}tool_name>
 
-For example:
+## Array Parameters
+
+To create an array of values for a parameter, repeat the parameter tag multiple times:
+
+<${toolNamePrefix}process_file>
+<${parameterPrefix}path>test.ts</${parameterPrefix}path>
+<${parameterPrefix}path>main.ts</${parameterPrefix}path>
+</${toolNamePrefix}process_file>
 
-<${toolNamePrefix}read_file>
-<${parameterPrefix}path>src/main.js</${parameterPrefix}path>
-</${toolNamePrefix}read_file>
+## Nested Object Parameters
+
+To create nested objects, nest parameter tags within other parameter tags:
+
+<${toolNamePrefix}example_tool>
+<${parameterPrefix}key>
+<${parameterPrefix}key2>value</${parameterPrefix}key2>
+<${parameterPrefix}key3>value2</${parameterPrefix}key3>
+</${parameterPrefix}key>
+</${toolNamePrefix}example_tool>
+
+You can also combine array parameters with nested objects:
+
+<${toolNamePrefix}example_tool>
+<${parameterPrefix}key>
+<${parameterPrefix}key2>value</${parameterPrefix}key2>
+<${parameterPrefix}key3>value2</${parameterPrefix}key3>
+</${parameterPrefix}key>
+<${parameterPrefix}key>
+<${parameterPrefix}key2>value3</${parameterPrefix}key2>
+<${parameterPrefix}key3>value4</${parameterPrefix}key3>
+<${parameterPrefix}key3>value5</${parameterPrefix}key3>
+</${parameterPrefix}key>
+</${toolNamePrefix}example_tool>
 
 Always adhere to this format for the tool use to ensure proper parsing and execution.
 
@@ -42288,7 +42434,7 @@ ${tools.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).joi
 ${tools.map((tool) => {
     let promp = "";
     for (const example of tool.examples ?? []) {
-      promp += toolInfoExamplesPrompt(exampleIndex++, tool, example, toolNamePrefix, parameterPrefix);
+      promp += toolInfoExamplesPrompt(tool, example, toolNamePrefix, parameterPrefix);
     }
     return promp;
   }).join("")}
@@ -43008,7 +43154,7 @@ You have access to two tools for working with files: **${toolNamePrefix}write_to
 
 ## Important Considerations
 
-- Using ${toolNamePrefix}write_to_file requires providing the file’s complete final content.
+- Using ${toolNamePrefix}write_to_file requires providing the file's complete final content.
 - If you only need to make small changes to an existing file, consider using ${toolNamePrefix}replace_in_file instead to avoid unnecessarily rewriting the entire file.
 - While ${toolNamePrefix}write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
 
@@ -43021,12 +43167,12 @@ You have access to two tools for working with files: **${toolNamePrefix}write_to
 ## When to Use
 
 - Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
-- Targeted improvements where only specific portions of the file’s content needs to be altered.
+- Targeted improvements where only specific portions of the file's content needs to be altered.
 - Especially useful for long files where much of the file will remain unchanged.
 
 ## Advantages
 
-- More efficient for minor edits, since you don’t need to supply the entire file content.
+- More efficient for minor edits, since you don't need to supply the entire file content.
 - Reduces the chance of errors that can occur when overwriting large files.
 
 # Choosing the Appropriate Tool
@@ -43052,41 +43198,39 @@ var rules = (toolNamePrefix) => `
 
 RULES
 
-- You may use \`cd\` to enter any child directory within the current working directory. For example, \`cd myChildDir\`. But you may never move to a parent directory or any directory outside your current path. For example, do not use \`cd ..\`, \`cd /\`, or any absolute path.
-- Always work with relative path names, and never use absolute paths.
-- When generating code or test or any file that support comments, add a comment on top of the file with a description of the file's purpose and a note that this file is generated by "polka.codes".
-- When generate text file such as README.md, add a footer indicating this file is generated by "polka.codes".
-- Before using the ${toolNamePrefix}execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory, and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command). For example, if you needed to run \`npm install\` in a project that's not in the current working directory, you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`. However, you can only cd into child directory, but never parent directory or root directory or home directory.
-- When using the ${toolNamePrefix}search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the ${toolNamePrefix}search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use ${toolNamePrefix}read_file to examine the full context of interesting matches before using ${toolNamePrefix}replace_in_file to make informed changes.
-- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when creating files, as the ${toolNamePrefix}write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
-- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
-- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
-- **Adhere to any established coding style, linting rules, or naming conventions if they are known or can be inferred from the existing codebase, to maintain consistency.**
-- When you want to modify a file, use the ${toolNamePrefix}replace_in_file or ${toolNamePrefix}write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
-- **Do not guess or hallucinate file content that has not been explicitly provided or read. Always read an existing file with \`${toolNamePrefix}read_file\` (or rely on content the user directly provided) before modifying it, unless you are creating a brand-new file.**
-- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the ${toolNamePrefix}attempt_completion tool to present the result to the user.
-- The user may provide a file's contents directly in their message, in which case you shouldn't use the ${toolNamePrefix}read_file tool to get the file contents again since you already have it.
-- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
-- NEVER end ${toolNamePrefix}attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
-- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
-- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
-- When using the ${toolNamePrefix}replace_in_file tool, you must include complete lines in your SEARCH blocks, not partial lines. The system requires exact line matches and cannot match partial lines. For example, if you want to match a line containing "const x = 5;", your SEARCH block must include the entire line, not just "x = 5" or other fragments.
-- When using the ${toolNamePrefix}replace_in_file tool, if you use multiple SEARCH/REPLACE blocks, list them in the order they appear in the file. For example if you need to make changes to both line 10 and line 50, first include the SEARCH/REPLACE block for line 10, followed by the SEARCH/REPLACE block for line 50.
-- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.
-- Keep the inline docs up to date if needed.
+- Work only with relative paths; you may \`cd\` into child directories but never use \`cd ..\`, root, or absolute paths.
+- When generating code, tests, or other comment-capable files, prepend a comment describing the file's purpose plus “generated by polka.codes”.
+  For text files (e.g. README.md), append a footer with the same notice.
+- Never describe what changed inside code comments; comments must focus on purpose or usage only.
+- Before using ${toolNamePrefix}execute_command, consider SYSTEM INFORMATION to ensure commands suit the user's OS. If a command must run in a subdirectory, prepend a single \`cd childDir &&\` segment.
+- Use ${toolNamePrefix}search_files for broad analysis, then ${toolNamePrefix}read_file to inspect context, and finally ${toolNamePrefix}replace_in_file or ${toolNamePrefix}write_to_file to modify.
+- Prefer ${toolNamePrefix}replace_in_file for focused edits; choose ${toolNamePrefix}write_to_file for new files or complete rewrites.
+- When creating a new file, look for existing files with similar content or patterns; if found, read them and use their structure or conventions as a reference.
+- SEARCH blocks in ${toolNamePrefix}replace_in_file must match whole lines. If multiple blocks are needed, list them in file order.
+- Do not guess unseen content. Read existing files first unless creating new ones.
+- Follow existing style, lint, and naming conventions. Ensure all changes compile and pass tests where applicable.
+- ALWAYS wait for the user's confirmation after each tool call before starting the next step.
+- The agent must never invoke more than 5 tools in a single response.
+- Do not end ${toolNamePrefix}attempt_completion output with questions or conversational prompts.
+- Avoid filler words like “Great”, “Certainly”, “Okay”, “Sure” at the start of responses; be direct and technical.
+- Keep inline documentation current as you edit.
 `;
 var objectives = (toolNamePrefix) => `
 ====
 
 OBJECTIVE
 
-You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+You solve the user's task by working in small, verifiable steps.
 
-1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
-2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
-3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use.
-4. Once you've completed the user's task, you must use the ${toolNamePrefix}attempt_completion tool to present the result of the task to the user.
-5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`;
+1. **Plan** - Parse the task, list clear goals, and order them logically.
+2. **Think** - Wrap private reasoning in <thinking></thinking>.
+   • Review project context.
+   • Select the single best tool for the next goal.
+   • Ensure every required parameter is available or can be inferred.
+3. **Act** - Invoke one tool per step. Wait for the system's response (and user confirmation where required) before continuing.
+4. **Iterate** - Repeat Plan → Think → Act until all goals are complete.
+5. **Complete** - Use ${toolNamePrefix}attempt_completion to deliver the final result. Do not invite further discussion unless the user explicitly requests changes.
+`;
 var fullSystemPrompt4 = (info2, tools, toolNamePrefix, instructions, scripts) => `
 ${basePrompt2}
 ${toolUsePrompt(tools, toolNamePrefix)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/cli",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",