@polka-codes/cli 0.8.6 → 0.8.8

package/dist/index.js

@@ -31550,7 +31550,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.8.6";
+var version = "0.8.8";
 
 // ../core/src/AiService/AiServiceBase.ts
 class AiServiceBase {
@@ -41029,6 +41029,7 @@ var toolInfo = {
       description: "One or more follow-up questions you need answered before you can continue.",
       required: true,
       allowMultiple: true,
+      usageValue: "questions here",
       children: [
         {
           name: "prompt",
@@ -42243,17 +42244,47 @@ var getAvailableTools = ({
 };
 
 // ../core/src/Agent/parseAssistantMessage.ts
-function parseNestedParameters(content, parameterPrefix) {
+function parseNestedParameters(content, parameterPrefix, childrenParams) {
   const result = {};
   const nestedParamRegex = new RegExp(`<${parameterPrefix}([^>]+)>([\\s\\S]*?)<\\/${parameterPrefix}\\1>`, "gs");
+  const arrayParams = new Set;
+  if (childrenParams) {
+    for (const param of childrenParams) {
+      if (param.allowMultiple) {
+        arrayParams.add(param.name);
+      }
+    }
+  }
   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);
+    const childParam = childrenParams?.find((p2) => p2.name === paramName);
+    if (paramContent.includes(`<${parameterPrefix}`) && childParam?.children) {
+      const nestedResult = parseNestedParameters(paramContent, parameterPrefix, childParam.children);
+      if (arrayParams.has(paramName)) {
+        if (!result[paramName]) {
+          result[paramName] = [];
+        }
+        if (Array.isArray(result[paramName])) {
+          result[paramName].push(nestedResult);
+        } else {
+          result[paramName] = [nestedResult];
+        }
+      } else {
+        result[paramName] = nestedResult;
+      }
+    } else if (arrayParams.has(paramName)) {
+      if (!result[paramName]) {
+        result[paramName] = [];
+      }
+      if (Array.isArray(result[paramName])) {
+        result[paramName].push(paramContent);
+      } else {
+        result[paramName] = [paramContent];
+      }
     } else {
       result[paramName] = paramContent;
     }
@@ -42297,15 +42328,29 @@ function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
           paramMatches.push(paramMatch[1].trim());
         }
         if (paramMatches.length > 0) {
-          if (paramMatches.length === 1) {
+          if (paramMatches.length === 1 && !param.allowMultiple) {
             const paramContent = paramMatches[0];
-            if (paramContent.includes(`<${parameterPrefix}`)) {
-              params[param.name] = parseNestedParameters(paramContent, parameterPrefix);
+            if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
+              params[param.name] = parseNestedParameters(paramContent, parameterPrefix, param.children);
             } else {
               params[param.name] = paramContent;
             }
           } else {
-            params[param.name] = paramMatches;
+            if (param.allowMultiple) {
+              params[param.name] = paramMatches.map((paramContent) => {
+                if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
+                  return parseNestedParameters(paramContent, parameterPrefix, param.children);
+                }
+                return paramContent;
+              });
+            } else {
+              const paramContent = paramMatches[0];
+              if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
+                params[param.name] = parseNestedParameters(paramContent, parameterPrefix, param.children);
+              } else {
+                params[param.name] = paramContent;
+              }
+            }
           }
         }
       }
@@ -42358,12 +42403,13 @@ var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
 Description: ${tool.description}
 
 Parameters:
-${tool.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"}) ${param.description}`).join(`
+${tool.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"})${param.allowMultiple ? " (multiple allowed)" : ""} ${param.description}`).join(`
 `)}
 
 Usage:
 <${toolNamePrefix}${tool.name}>
-${tool.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
+${tool.parameters.map((param) => param.allowMultiple ? `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>
+<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>` : `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
 `)}
 </${toolNamePrefix}${tool.name}>`;
 var toolInfoExamplesPrompt = (tool, example, toolNamePrefix, parameterPrefix) => `
@@ -42894,42 +42940,35 @@ var fullSystemPrompt2 = (info2, tools, toolNamePrefix, instructions, scripts) =>
 ## Role
 You are the **Architect** agent, responsible for:
 1. **Task Analysis** - Understand requirements.
-2. **File Identification** - Find and select relevant files.
-3. **File Reading** - Use the provided tools to gather information from these files.
-4. **Implementation Plan** - Draft a detailed, unambiguous, *code-free* plan (pseudocode or interface stubs allowed).
-5. **Review & Improve** - Evaluate and refine the plan.
+2. **File Identification** - Select relevant files.
+3. **File Reading** - Use provided tools to gather information.
+4. **Implementation Plan** - Draft a *code-free* plan (pseudocode/interface stubs permitted).
+5. **Review & Improve** - Refine the plan.
 6. **Handover/Delegate** - Provide the final plan, context, and files to the **Coder** agent.
 
-> **Note**: The **Architect** agent must **never** modify project files directly. Your sole deliverable is the implementation plan; the **Coder** agent will perform all code changes.
+> **Never** modify project files directly. Only produce the implementation plan; the **Coder** agent performs all code changes.
 
 ## Rules
-1. **Consistency** - Always align with the user's instructions and project objectives.
-2. **Relevance** - Consult only files essential to the task.
-3. **Conciseness** - Communicate succinctly; avoid repetition.
-4. **Accuracy** - Ensure findings and conclusions are correct and verifiable.
-5. **Clarity** - Present information in a structured, easy-to-follow format.
-6. **Minimal Queries** - Ask clarifying questions only when essential; avoid redundant questioning.
+1. **Consistency** - Align with user objectives.
+2. **Relevance** - Consult only essential files.
+3. **Conciseness** - Be succinct; avoid repetition.
+4. **Accuracy** - Ensure conclusions are verifiable.
+5. **Clarity** - Present information in a structured format.
+6. **Minimal Queries** - Ask questions only when truly needed.
 
 ## Steps
-1. **Analyze Task**
-   - Capture requirements, constraints, and objectives.
-
-2. **Identify Relevant Files**
-   - List the specific files needed and justify each selection.
-
-3. **Read Files via Tools**
-   - Extract key information with provided tools and summarize insights.
-
-4. **Create Implementation Plan**
-   - Produce a **detailed, step-by-step plan** that:
-     - Describes tasks, resources, and dependencies.
-     - Uses pseudocode or interface declarations *only*—no concrete code.
-     - Is explicit enough for the **Coder** agent to implement without further clarification.
-
-5. **Handover/Delegate**
+1. **Analyze Task** - Capture goals, constraints, and success criteria.
+2. **Identify Relevant Files** - List files and justify each choice.
+3. **Read Files via Tools** - Summarize key insights.
+4. **Create Implementation Plan** - Provide a detailed, step-by-step breakdown:
+   * Tasks, resources, and dependencies.
+   * Pseudocode or interface declarations only—no concrete code.
+   * Sufficient detail for the **Coder** to implement without follow-ups.
+5. **Review & Improve** - Confirm the plan is unambiguous and complete.
+6. **Handover/Delegate**
    - If the plan consists of a single self-contained step, hand it over as one task.
-   - If multiple steps are required, break them into numbered tasks for the **Coder** agent.
-   - Provide all necessary context, file references, and clarifications for successful execution.
+   - If multiple steps are required, break them into numbered tasks to delegate to the **Coder** agent.
+   - Provide all necessary context, implementation plan, file references, and clarifications for successful execution.
 
 ${toolUsePrompt(tools, toolNamePrefix)}
 ${capabilities(toolNamePrefix)}

package/package.json

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