@polka-codes/cli-shared 0.8.3 → 0.8.5

package/dist/index.js

@@ -36840,10 +36840,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) => {
@@ -36857,6 +36863,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) => {
@@ -36867,13 +36876,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) => {
@@ -36884,50 +36896,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"]
+          }
         }
       ]
     }
@@ -36941,13 +37007,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) => {
@@ -37084,33 +37163,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" }
       ]
     }
   ],
@@ -38072,6 +38145,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 = [];
@@ -38100,10 +38190,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({
@@ -38135,6 +38240,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}
 
@@ -38149,11 +38268,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}>
 `;
@@ -38162,7 +38281,6 @@ var toolUsePrompt = (tools, toolNamePrefix) => {
     return "";
   }
   const parameterPrefix = `${toolNamePrefix}parameter_`;
-  let exampleIndex = 0;
   return `
 ====
 
@@ -38180,11 +38298,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>
+
+## 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}read_file>
-<${parameterPrefix}path>src/main.js</${parameterPrefix}path>
-</${toolNamePrefix}read_file>
+<${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.
 
@@ -38198,7 +38344,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("")}

package/package.json

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