@polka-codes/cli 0.9.35 → 0.9.37

package/dist/index.js

@@ -58608,7 +58608,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.35";
+var version = "0.9.37";
 
 // src/commands/chat.ts
 import { readFile as readFile3 } from "node:fs/promises";
@@ -72136,14 +72136,23 @@ var handler4 = async (provider, args) => {
   try {
     console.log("Executing command:", command, "Requires approval:", requiresApproval);
     const result = await provider.executeCommand(command, requiresApproval);
-    const message = `<command>${command}</command>
+    let message = `<command>${command}</command>
 <command_exit_code>${result.exitCode}</command_exit_code>
-<command_stdout>
+`;
+    if (result.summary) {
+      message += `<command_output_summary>
+${result.summary}
+</command_output_summary>
+`;
+    } else {
+      message += `<command_stdout>
 ${result.stdout}
 </command_stdout>
 <command_stderr>
 ${result.stderr}
-</command_stderr>`;
+</command_stderr>
+`;
+    }
     if (result.exitCode === 0) {
       return {
         type: "Reply" /* Reply */,
@@ -73186,6 +73195,14 @@ class UsageMeter {
   get usage() {
     return { ...this.#totals };
   }
+  merge(other) {
+    const otherUsage = other.usage;
+    this.#totals.input += otherUsage.input;
+    this.#totals.output += otherUsage.output;
+    this.#totals.cachedRead += otherUsage.cachedRead;
+    this.#totals.cost += otherUsage.cost;
+    this.#totals.messageCount += otherUsage.messageCount;
+  }
   printUsage(customConsole = console) {
     const u = this.usage;
     customConsole.log(`Usage - messages: ${u.messageCount}, input: ${u.input}, cached: ${u.cachedRead}, ` + `output: ${u.output}, cost: $${u.cost.toFixed(4)}`);
@@ -81013,6 +81030,13 @@ function prepareRetries({
     })
   };
 }
+function extractTextContent(content) {
+  const parts = content.filter((content2) => content2.type === "text");
+  if (parts.length === 0) {
+    return;
+  }
+  return parts.map((content2) => content2.text).join("");
+}
 var DefaultGeneratedFile = class {
   constructor({
     data,
@@ -81304,6 +81328,519 @@ var originalGenerateId = createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
+async function generateText({
+  model: modelArg,
+  tools,
+  toolChoice,
+  system,
+  prompt,
+  messages,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  stopWhen = stepCountIs(1),
+  experimental_output: output,
+  experimental_telemetry: telemetry,
+  providerOptions,
+  experimental_activeTools,
+  activeTools = experimental_activeTools,
+  experimental_prepareStep,
+  prepareStep = experimental_prepareStep,
+  experimental_repairToolCall: repairToolCall,
+  experimental_download: download2,
+  experimental_context,
+  _internal: {
+    generateId: generateId3 = originalGenerateId,
+    currentDate = () => /* @__PURE__ */ new Date
+  } = {},
+  onStepFinish,
+  ...settings
+}) {
+  const model = resolveLanguageModel(modelArg);
+  const stopConditions = asArray(stopWhen);
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const callSettings = prepareCallSettings(settings);
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model,
+    telemetry,
+    headers,
+    settings: { ...callSettings, maxRetries }
+  });
+  const initialPrompt = await standardizePrompt({
+    system,
+    prompt,
+    messages
+  });
+  const tracer = getTracer(telemetry);
+  try {
+    return await recordSpan({
+      name: "ai.generateText",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.generateText",
+            telemetry
+          }),
+          ...baseTelemetryAttributes,
+          "ai.model.provider": model.provider,
+          "ai.model.id": model.modelId,
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          }
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        var _a172, _b8, _c, _d, _e, _f, _g;
+        const callSettings2 = prepareCallSettings(settings);
+        let currentModelResponse;
+        let clientToolCalls = [];
+        let clientToolOutputs = [];
+        const responseMessages = [];
+        const steps = [];
+        do {
+          const stepInputMessages = [
+            ...initialPrompt.messages,
+            ...responseMessages
+          ];
+          const prepareStepResult = await (prepareStep == null ? undefined : prepareStep({
+            model,
+            steps,
+            stepNumber: steps.length,
+            messages: stepInputMessages
+          }));
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: {
+              system: (_a172 = prepareStepResult == null ? undefined : prepareStepResult.system) != null ? _a172 : initialPrompt.system,
+              messages: (_b8 = prepareStepResult == null ? undefined : prepareStepResult.messages) != null ? _b8 : stepInputMessages
+            },
+            supportedUrls: await model.supportedUrls,
+            download: download2
+          });
+          const stepModel = resolveLanguageModel((_c = prepareStepResult == null ? undefined : prepareStepResult.model) != null ? _c : model);
+          const { toolChoice: stepToolChoice, tools: stepTools } = prepareToolsAndToolChoice({
+            tools,
+            toolChoice: (_d = prepareStepResult == null ? undefined : prepareStepResult.toolChoice) != null ? _d : toolChoice,
+            activeTools: (_e = prepareStepResult == null ? undefined : prepareStepResult.activeTools) != null ? _e : activeTools
+          });
+          currentModelResponse = await retry(() => {
+            var _a18;
+            return recordSpan({
+              name: "ai.generateText.doGenerate",
+              attributes: selectTelemetryAttributes({
+                telemetry,
+                attributes: {
+                  ...assembleOperationName({
+                    operationId: "ai.generateText.doGenerate",
+                    telemetry
+                  }),
+                  ...baseTelemetryAttributes,
+                  "ai.model.provider": stepModel.provider,
+                  "ai.model.id": stepModel.modelId,
+                  "ai.prompt.messages": {
+                    input: () => stringifyForTelemetry(promptMessages)
+                  },
+                  "ai.prompt.tools": {
+                    input: () => stepTools == null ? undefined : stepTools.map((tool3) => JSON.stringify(tool3))
+                  },
+                  "ai.prompt.toolChoice": {
+                    input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : undefined
+                  },
+                  "gen_ai.system": stepModel.provider,
+                  "gen_ai.request.model": stepModel.modelId,
+                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
+                  "gen_ai.request.presence_penalty": settings.presencePenalty,
+                  "gen_ai.request.stop_sequences": settings.stopSequences,
+                  "gen_ai.request.temperature": (_a18 = settings.temperature) != null ? _a18 : undefined,
+                  "gen_ai.request.top_k": settings.topK,
+                  "gen_ai.request.top_p": settings.topP
+                }
+              }),
+              tracer,
+              fn: async (span2) => {
+                var _a19, _b22, _c2, _d2, _e2, _f2, _g2, _h;
+                const result = await stepModel.doGenerate({
+                  ...callSettings2,
+                  tools: stepTools,
+                  toolChoice: stepToolChoice,
+                  responseFormat: output == null ? undefined : output.responseFormat,
+                  prompt: promptMessages,
+                  providerOptions,
+                  abortSignal,
+                  headers
+                });
+                const responseData = {
+                  id: (_b22 = (_a19 = result.response) == null ? undefined : _a19.id) != null ? _b22 : generateId3(),
+                  timestamp: (_d2 = (_c2 = result.response) == null ? undefined : _c2.timestamp) != null ? _d2 : currentDate(),
+                  modelId: (_f2 = (_e2 = result.response) == null ? undefined : _e2.modelId) != null ? _f2 : stepModel.modelId,
+                  headers: (_g2 = result.response) == null ? undefined : _g2.headers,
+                  body: (_h = result.response) == null ? undefined : _h.body
+                };
+                span2.setAttributes(selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    "ai.response.finishReason": result.finishReason,
+                    "ai.response.text": {
+                      output: () => extractTextContent(result.content)
+                    },
+                    "ai.response.toolCalls": {
+                      output: () => {
+                        const toolCalls = asToolCalls(result.content);
+                        return toolCalls == null ? undefined : JSON.stringify(toolCalls);
+                      }
+                    },
+                    "ai.response.id": responseData.id,
+                    "ai.response.model": responseData.modelId,
+                    "ai.response.timestamp": responseData.timestamp.toISOString(),
+                    "ai.response.providerMetadata": JSON.stringify(result.providerMetadata),
+                    "ai.usage.promptTokens": result.usage.inputTokens,
+                    "ai.usage.completionTokens": result.usage.outputTokens,
+                    "gen_ai.response.finish_reasons": [result.finishReason],
+                    "gen_ai.response.id": responseData.id,
+                    "gen_ai.response.model": responseData.modelId,
+                    "gen_ai.usage.input_tokens": result.usage.inputTokens,
+                    "gen_ai.usage.output_tokens": result.usage.outputTokens
+                  }
+                }));
+                return { ...result, response: responseData };
+              }
+            });
+          });
+          const stepToolCalls = await Promise.all(currentModelResponse.content.filter((part) => part.type === "tool-call").map((toolCall) => parseToolCall({
+            toolCall,
+            tools,
+            repairToolCall,
+            system,
+            messages: stepInputMessages
+          })));
+          for (const toolCall of stepToolCalls) {
+            if (toolCall.invalid) {
+              continue;
+            }
+            const tool3 = tools[toolCall.toolName];
+            if ((tool3 == null ? undefined : tool3.onInputAvailable) != null) {
+              await tool3.onInputAvailable({
+                input: toolCall.input,
+                toolCallId: toolCall.toolCallId,
+                messages: stepInputMessages,
+                abortSignal,
+                experimental_context
+              });
+            }
+          }
+          const invalidToolCalls = stepToolCalls.filter((toolCall) => toolCall.invalid && toolCall.dynamic);
+          clientToolOutputs = [];
+          for (const toolCall of invalidToolCalls) {
+            clientToolOutputs.push({
+              type: "tool-error",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              error: getErrorMessage2(toolCall.error),
+              dynamic: true
+            });
+          }
+          clientToolCalls = stepToolCalls.filter((toolCall) => !toolCall.providerExecuted);
+          if (tools != null) {
+            clientToolOutputs.push(...await executeTools({
+              toolCalls: clientToolCalls.filter((toolCall) => !toolCall.invalid),
+              tools,
+              tracer,
+              telemetry,
+              messages: stepInputMessages,
+              abortSignal,
+              experimental_context
+            }));
+          }
+          const stepContent = asContent({
+            content: currentModelResponse.content,
+            toolCalls: stepToolCalls,
+            toolOutputs: clientToolOutputs
+          });
+          responseMessages.push(...toResponseMessages({
+            content: stepContent,
+            tools
+          }));
+          const currentStepResult = new DefaultStepResult({
+            content: stepContent,
+            finishReason: currentModelResponse.finishReason,
+            usage: currentModelResponse.usage,
+            warnings: currentModelResponse.warnings,
+            providerMetadata: currentModelResponse.providerMetadata,
+            request: (_f = currentModelResponse.request) != null ? _f : {},
+            response: {
+              ...currentModelResponse.response,
+              messages: structuredClone(responseMessages)
+            }
+          });
+          logWarnings((_g = currentModelResponse.warnings) != null ? _g : []);
+          steps.push(currentStepResult);
+          await (onStepFinish == null ? undefined : onStepFinish(currentStepResult));
+        } while (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length && !await isStopConditionMet({ stopConditions, steps }));
+        span.setAttributes(selectTelemetryAttributes({
+          telemetry,
+          attributes: {
+            "ai.response.finishReason": currentModelResponse.finishReason,
+            "ai.response.text": {
+              output: () => extractTextContent(currentModelResponse.content)
+            },
+            "ai.response.toolCalls": {
+              output: () => {
+                const toolCalls = asToolCalls(currentModelResponse.content);
+                return toolCalls == null ? undefined : JSON.stringify(toolCalls);
+              }
+            },
+            "ai.response.providerMetadata": JSON.stringify(currentModelResponse.providerMetadata),
+            "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
+            "ai.usage.completionTokens": currentModelResponse.usage.outputTokens
+          }
+        }));
+        const lastStep = steps[steps.length - 1];
+        return new DefaultGenerateTextResult({
+          steps,
+          resolvedOutput: await (output == null ? undefined : output.parseOutput({ text: lastStep.text }, {
+            response: lastStep.response,
+            usage: lastStep.usage,
+            finishReason: lastStep.finishReason
+          }))
+        });
+      }
+    });
+  } catch (error43) {
+    throw wrapGatewayError(error43);
+  }
+}
+async function executeTools({
+  toolCalls,
+  tools,
+  tracer,
+  telemetry,
+  messages,
+  abortSignal,
+  experimental_context
+}) {
+  const toolOutputs = await Promise.all(toolCalls.map(async ({ toolCallId, toolName, input }) => {
+    const tool3 = tools[toolName];
+    if ((tool3 == null ? undefined : tool3.execute) == null) {
+      return;
+    }
+    return recordSpan({
+      name: "ai.toolCall",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.toolCall",
+            telemetry
+          }),
+          "ai.toolCall.name": toolName,
+          "ai.toolCall.id": toolCallId,
+          "ai.toolCall.args": {
+            output: () => JSON.stringify(input)
+          }
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        try {
+          const stream = executeTool({
+            execute: tool3.execute.bind(tool3),
+            input,
+            options: {
+              toolCallId,
+              messages,
+              abortSignal,
+              experimental_context
+            }
+          });
+          let output;
+          for await (const part of stream) {
+            if (part.type === "final") {
+              output = part.output;
+            }
+          }
+          try {
+            span.setAttributes(selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.toolCall.result": {
+                  output: () => JSON.stringify(output)
+                }
+              }
+            }));
+          } catch (ignored) {}
+          return {
+            type: "tool-result",
+            toolCallId,
+            toolName,
+            input,
+            output,
+            dynamic: tool3.type === "dynamic"
+          };
+        } catch (error43) {
+          recordErrorOnSpan(span, error43);
+          return {
+            type: "tool-error",
+            toolCallId,
+            toolName,
+            input,
+            error: error43,
+            dynamic: tool3.type === "dynamic"
+          };
+        }
+      }
+    });
+  }));
+  return toolOutputs.filter((output) => output != null);
+}
+var DefaultGenerateTextResult = class {
+  constructor(options) {
+    this.steps = options.steps;
+    this.resolvedOutput = options.resolvedOutput;
+  }
+  get finalStep() {
+    return this.steps[this.steps.length - 1];
+  }
+  get content() {
+    return this.finalStep.content;
+  }
+  get text() {
+    return this.finalStep.text;
+  }
+  get files() {
+    return this.finalStep.files;
+  }
+  get reasoningText() {
+    return this.finalStep.reasoningText;
+  }
+  get reasoning() {
+    return this.finalStep.reasoning;
+  }
+  get toolCalls() {
+    return this.finalStep.toolCalls;
+  }
+  get staticToolCalls() {
+    return this.finalStep.staticToolCalls;
+  }
+  get dynamicToolCalls() {
+    return this.finalStep.dynamicToolCalls;
+  }
+  get toolResults() {
+    return this.finalStep.toolResults;
+  }
+  get staticToolResults() {
+    return this.finalStep.staticToolResults;
+  }
+  get dynamicToolResults() {
+    return this.finalStep.dynamicToolResults;
+  }
+  get sources() {
+    return this.finalStep.sources;
+  }
+  get finishReason() {
+    return this.finalStep.finishReason;
+  }
+  get warnings() {
+    return this.finalStep.warnings;
+  }
+  get providerMetadata() {
+    return this.finalStep.providerMetadata;
+  }
+  get response() {
+    return this.finalStep.response;
+  }
+  get request() {
+    return this.finalStep.request;
+  }
+  get usage() {
+    return this.finalStep.usage;
+  }
+  get totalUsage() {
+    return this.steps.reduce((totalUsage, step) => {
+      return addLanguageModelUsage(totalUsage, step.usage);
+    }, {
+      inputTokens: undefined,
+      outputTokens: undefined,
+      totalTokens: undefined,
+      reasoningTokens: undefined,
+      cachedInputTokens: undefined
+    });
+  }
+  get experimental_output() {
+    if (this.resolvedOutput == null) {
+      throw new NoOutputSpecifiedError;
+    }
+    return this.resolvedOutput;
+  }
+};
+function asToolCalls(content) {
+  const parts = content.filter((part) => part.type === "tool-call");
+  if (parts.length === 0) {
+    return;
+  }
+  return parts.map((toolCall) => ({
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input
+  }));
+}
+function asContent({
+  content,
+  toolCalls,
+  toolOutputs
+}) {
+  return [
+    ...content.map((part) => {
+      switch (part.type) {
+        case "text":
+        case "reasoning":
+        case "source":
+          return part;
+        case "file": {
+          return {
+            type: "file",
+            file: new DefaultGeneratedFile(part)
+          };
+        }
+        case "tool-call": {
+          return toolCalls.find((toolCall) => toolCall.toolCallId === part.toolCallId);
+        }
+        case "tool-result": {
+          const toolCall = toolCalls.find((toolCall2) => toolCall2.toolCallId === part.toolCallId);
+          if (toolCall == null) {
+            throw new Error(`Tool call ${part.toolCallId} not found.`);
+          }
+          if (part.isError) {
+            return {
+              type: "tool-error",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: toolCall.input,
+              error: part.result,
+              providerExecuted: true,
+              dynamic: toolCall.dynamic
+            };
+          }
+          return {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: toolCall.input,
+            output: part.result,
+            providerExecuted: true,
+            dynamic: toolCall.dynamic
+          };
+        }
+      }
+    }),
+    ...toolOutputs
+  ];
+}
 function prepareHeaders(headers, defaultHeaders) {
   const responseHeaders = new Headers(headers != null ? headers : {});
   for (const [key2, value] of Object.entries(defaultHeaders)) {
@@ -85084,6 +85621,7 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
       };
       try {
         resetTimeout();
+        const usageMeterOnFinishHandler = this.config.usageMeter.onFinishHandler(this.ai);
         const streamTextOptions = {
           model: this.ai,
           temperature: 0,
@@ -85102,7 +85640,10 @@ Request timeout after ${requestTimeoutSeconds} seconds. Canceling current reques
                 break;
             }
           },
-          onFinish: this.config.usageMeter.onFinishHandler(this.ai),
+          onFinish: (evt) => {
+            usageMeterOnFinishHandler(evt);
+            this.#callback({ kind: "Usage" /* Usage */, agent: this, usage: evt.totalUsage });
+          },
           onError: async (error43) => {
             console.error("Error in stream:", error43);
           },
@@ -86177,6 +86718,7 @@ var configSchema = exports_external.object({
   budget: exports_external.number().positive().optional(),
   retryCount: exports_external.number().int().min(0).optional(),
   requestTimeoutSeconds: exports_external.number().int().positive().optional(),
+  summaryThreshold: exports_external.number().int().positive().optional(),
   scripts: exports_external.record(exports_external.string(), exports_external.string().or(exports_external.object({
     command: exports_external.string(),
     description: exports_external.string()
@@ -105238,8 +105780,25 @@ var getProvider = (options = {}) => {
           options.command?.onStderr(dataStr);
           stderrText += dataStr;
         });
-        child.on("close", (code) => {
+        child.on("close", async (code) => {
           options.command?.onExit(code ?? 0);
+          const totalLength = stdoutText.length + stderrText.length;
+          if (totalLength > (options.summaryThreshold ?? 5000) && options.summarizeOutput) {
+            try {
+              const summary = await options.summarizeOutput(stdoutText, stderrText);
+              if (summary) {
+                resolve7({
+                  summary,
+                  stdout: stdoutText,
+                  stderr: stderrText,
+                  exitCode: code ?? 0
+                });
+                return;
+              }
+            } catch (_e) {
+              console.error("Summarization failed:", _e);
+            }
+          }
           resolve7({
             stdout: stdoutText,
             stderr: stderrText,
@@ -106029,6 +106588,201 @@ import { readFile as readFile2 } from "node:fs/promises";
 import os3 from "node:os";
 var import_lodash5 = __toESM(require_lodash(), 1);
 
+// src/commandSummarizer.ts
+var prompt3 = `
+System Prompt: Command Output Summarizer
+
+Role
+- You are a coding agent that summarizes command execution results.
+- You receive raw stdout and stderr and must produce a concise, high-signal summary focused on what matters to developers.
+
+Input
+- The input will ALWAYS be provided in this exact format:
+  <stdout>
+  \${stdout}
+  </stdout>
+  <stderr>
+  \${stderr}
+  </stderr>
+- Treat missing or empty sections as empty strings.
+
+Core Objective
+- Extract and report ONLY the key lines that communicate failures, warnings, and actionable issues.
+- Ignore routine noise: progress bars, spinners, timestamps, banners, environment echoes, compilation start/finish messages, and other benign status lines.
+- Prefer brevity and accuracy. Do not ask questions. Do not repeat yourself.
+
+General Rules
+1) Preprocessing
+   - Normalize newlines to "
+"; strip ANSI colors/escape codes.
+   - Collapse repeated blank lines; trim trailing whitespace.
+   - Deduplicate identical lines that appear many times; show one and append " (repeated N times)".
+   - Truncate extremely long single lines to a reasonable width while preserving the essential portion (start and end), indicating truncation with "...".
+   - Redact obvious secrets (tokens, passwords, keys) by masking the middle with "****", keeping at most the last 4 chars.
+
+2) Severity and Ordering
+   - Prioritize in this order: Errors, Test Failures, Warnings, Important Notes.
+   - Preserve original order within each section when helpful for debugging.
+   - If an exit code is inferable (e.g., via error footers or phrases like "exit status 1"), include it in the Summary.
+
+3) Output Format (ASCII only, no tables)
+   - Summary: one short line if any issues were found.
+     Example: "Summary: exit_code=1; errors=3; warnings=2; failing_tests=4"
+   - Then zero or more sections in this order, only if present:
+     - Errors:
+     - Test Failures:
+     - Warnings:
+     - Notes:
+   - Within each section, use compact bullet points ("- ").
+   - Quote key lines verbatim when they carry the signal (file:line:col, codes, rule names, assertion diffs).
+   - Never include large code blocks; include at most 1-2 context lines around a key message when indispensable, marked with "...".
+
+4) What to Include vs Ignore (by tool/type)
+   A) Test Runners (jest, mocha, vitest, pytest, nose, unittest, go test, rspec, junit, maven-surefire, gradle test)
+      Include:
+        - Names of failing test suites and test cases.
+        - Assertion messages, diffs (Expected vs Received / AssertionError messages).
+        - First 1-3 relevant stack frames pointing to user code (omit framework internals).
+        - Summary counts: failed, skipped (if significant), total time if useful.
+      Ignore:
+        - Passed tests, pass counts, coverage success lines.
+        - Test discovery notices, "OK"/"PASSED" banners, shard routing info.
+      Example bullet:
+        - tests/math.spec.ts: "adds numbers" FAILED: Expected 3, Received 4 at src/math.ts:12:7
+
+   B) Compilers/Build Tools (tsc, vite, webpack, esbuild, babel, gcc/clang, javac, kotlinc, rustc/cargo, go build, dotnet build, swiftc)
+      Include:
+        - Errors and warnings only (file:line:col if present, diagnostic code).
+        - Linker errors and type mismatch details.
+      Ignore:
+        - Status/progress lines like "Compiling X", "Bundling Y", "Starting dev server...", "Note: some messages have been simplified".
+      Example bullets:
+        - src/foo.ts:42:13 TS2339 error: Property 'bar' does not exist on type 'Baz'.
+        - lib/util.c:88:5 warning: unused variable 'tmp' [-Wunused-variable]
+
+   C) Linters/Formatters (eslint, flake8, pylint, rubocop, golangci-lint, stylelint, mypy, black/prettier)
+      Include:
+        - Violations with file:line:col, rule/id, brief message.
+        - mypy type errors (treat as errors).
+      Ignore:
+        - "All matched files" summaries, formatter no-op messages.
+      Example bullet:
+        - src/app.tsx:17:9 eslint(no-unused-vars): 'user' is assigned a value but never used.
+
+   D) Runtime/Execution Errors (node, python, java, go, ruby, dotnet, shell)
+      Include:
+        - Error type/name and message.
+        - Top 1-3 stack frames in user code; include "Caused by" chains.
+        - Non-zero exit status if visible.
+      Ignore:
+        - Long internal/framework stacks unless they are the only frames available.
+      Example bullet:
+        - RuntimeError: connection refused at services/db.py:54 (exit status 1)
+
+   E) Package/Build Systems (npm/yarn/pnpm, pip/pipenv, poetry, cargo, maven, gradle)
+      Include:
+        - Install/build failures, script failures, postinstall errors.
+        - Security advisories at high/critical severity (count + top advisory IDs).
+        - Missing/invalid peer dependency errors that break install/build.
+      Ignore:
+        - Progress bars, fetch logs, cache hits, "up to date" lines.
+      Example bullet:
+        - npm ERR! test script failed: "jest --runInBand" (code 1)
+
+   F) VCS and CI (git, gh, svn; CI logs)
+      Include:
+        - Merge/rebase conflicts (files and conflict markers).
+        - Push rejections (non-fast-forward, auth failures).
+        - CI job failures (job name, failing step, error excerpt).
+      Ignore:
+        - Clean status, branch listings unless indicating a problem.
+      Example bullet:
+        - Merge conflict: src/index.ts (markers found around lines ~120-145)
+
+   G) Containers/Orchestration (docker, podman, kubectl, helm)
+      Include:
+        - Build failures (failed stages, missing files), run-time exit codes.
+        - Kubernetes apply errors and crashloop events with reason.
+      Ignore:
+        - Layer download progress, pull status noise.
+      Example bullet:
+        - CrashLoopBackOff: pod api-7f6c... container "api" OOMKilled (restart 3/5)
+
+   H) Databases/SQL/Migrations (psql, mysql, sqlite, prisma, liquibase, flyway)
+      Include:
+        - SQLSTATE/error codes, constraint violations, migration failure details.
+      Example bullet:
+        - SQLSTATE 23505 unique_violation on users(email) at 2025-09-11T03:22Z
+
+5) Counts and Grouping
+   - If 3+ similar diagnostics occur, summarize with a count and show 1-2 exemplars:
+     Example: "Type errors (7): e.g., src/a.ts:10 TS2322: Type 'X' is not assignable to 'Y'."
+   - When possible, group by file or rule to reduce noise.
+
+6) Stack Traces
+   - Keep only the topmost relevant frames pointing to project files (e.g., paths under src/, app/, lib/).
+   - Omit frames from node:internal, <anonymous>, site-packages/dist-packages unless they are the only frames.
+
+7) Timeouts/Resource Failures
+   - If a timeout/OOM/segfault is detected, surface it prominently under Errors with the best short cause line.
+
+8) When There Is Nothing Noteworthy
+   - If no errors, no warnings, and no failing tests are detected, output a single line:
+     "No issues found."
+   - Do NOT restate benign status like "build succeeded" or "all tests passed".
+
+9) Tone and Style
+   - Be precise and unemotional.
+   - Use short bullets; avoid prose paragraphs.
+   - ASCII only; no emojis; no tables.
+
+10) Optional Next Actions
+   - If and only if issues exist, append a short "Next actions:" section with up to 3 bullets of direct, obvious steps derived from the messages (e.g., "Fix missing import in src/foo.ts line 12").
+
+Detection Heuristics (non-exhaustive)
+- Errors: lines containing "error", "ERR!", "E ", "fatal", "Traceback", "Exception", "undefined reference", "cannot find symbol", "not found", "Segmentation fault", "panic:", "stack overflow".
+- Warnings: lines containing "warning", "WARN", "deprecated", "note: this will be removed" (treat "note" as warning only if explicitly labeled).
+- Test failures: lines with "FAIL", "FAILED", "Error", "AssertionError", "expect(", "--- FAIL:", "not ok", "Tests failed", or junit/pytest summaries with non-zero failures.
+
+Output Template
+- Follow this shape; omit empty sections:
+
+  Summary: exit_code=<code>; errors=<N>; warnings=<M>; failing_tests=<K>
+  Errors:
+  - <file:line:col> <diagnostic code if any> <short message>
+  - <next...>
+
+  Test Failures:
+  - <suite or file> "<test name>": <assertion message or diff>; at <file:line[:col]>
+  - <next...>
+
+  Warnings:
+  - <file:line:col> <rule/code>: <short message>
+
+  Notes:
+  - <concise note if indispensable>
+
+  Next actions:
+  - <up to 3 short, concrete steps>
+
+Final Requirements
+- Be concise, avoid repeating the same information.
+- Ensure accuracy; never invent details not present in the input.
+- Do not output tables unless explicitly asked.`;
+var summarizeOutput = async (model, stdout, stderr) => {
+  const resp = await generateText({
+    model,
+    system: prompt3,
+    prompt: `<stdout>
+${stdout}
+</stdout>
+<stderr>
+${stderr}
+</stderr>`
+  });
+  return resp.text;
+};
+
 // src/getProviderOptions.ts
 function getProviderOptions(provider3, modelId, thinkingBudgetTokens, supportThinking) {
   if (thinkingBudgetTokens <= 0 || !provider3 || !modelId) {
@@ -106108,7 +106862,8 @@ class Runner {
           console.log(`$ <<<< $ Command error: ${error43}`);
         }
       },
-      excludeFiles: options.config.excludeFiles
+      excludeFiles: options.config.excludeFiles,
+      summaryThreshold: options.config.summaryThreshold
     };
     const platform = os3.platform();
     const llms = {};
@@ -106161,6 +106916,12 @@ class Runner {
         if (this.#options.interactive) {
           additionalTools.push(askFollowupQuestion_default);
         }
+        const newToolProviderOptions = {
+          ...toolProviderOptions,
+          summarizeOutput: async (stdout, stderr) => {
+            return await summarizeOutput(ai, stdout, stderr);
+          }
+        };
         const args = {
           ai,
           os: platform,
@@ -106178,7 +106939,7 @@ class Runner {
           },
           usageMeter: this.usageMeter,
           additionalTools,
-          provider: getProvider(toolProviderOptions)
+          provider: getProvider(newToolProviderOptions)
         };
         switch (agentName) {
           case coderAgentInfo.name:
@@ -108394,9 +109155,10 @@ var getChangeInfo = {
   id: "get-change-info",
   type: "custom",
   run: async (input, context, _resumedState) => {
-    const { pr, json: json2 } = input;
+    const { pr, json: json2, yes } = input;
     const logger = context.logger ?? console;
     context.json = json2;
+    context.yes = yes;
     const {
       ui: { spinner }
     } = context;
@@ -108540,6 +109302,7 @@ var handleResult3 = {
   run: async (input, context, _resumedState) => {
     const { overview, specificReviews } = input;
     const json2 = context.json;
+    const yes = context.yes;
     const logger = context.logger ?? console;
     const {
       ui: { spinner }
@@ -108558,14 +109321,18 @@ var handleResult3 = {
     const formatted = formatReviewForConsole(reviewResult);
     logger.log(formatted);
     let shouldRunTask = false;
-    if (process.stdin.isTTY && reviewResult.specificReviews.length > 0) {
-      try {
-        shouldRunTask = await esm_default2({
-          message: "Do you wish polka-codes to address the review results?",
-          default: false
-        });
-      } catch {
-        process.exit(130);
+    if (reviewResult.specificReviews.length > 0) {
+      if (yes) {
+        shouldRunTask = true;
+      } else if (process.stdin.isTTY) {
+        try {
+          shouldRunTask = await esm_default2({
+            message: "Do you wish polka-codes to address the review results?",
+            default: false
+          });
+        } catch {
+          process.exit(130);
+        }
       }
     }
     const output = { shouldRunTask };
@@ -108831,31 +109598,62 @@ async function runTask(taskArg, _options, command2, opts = {}) {
 }
 
 // src/commands/review.ts
-var reviewCommand = new Command("review").description("Review a GitHub pull request or local changes").option("--pr <pr>", "The pull request number or URL to review").option("--json", "Output the review in JSON format", false).action(async (options, command2) => {
-  const { json: json2, pr: pr2 } = options;
-  const input = { json: json2, ...pr2 && { pr: pr2 } };
-  let _willRunTask = false;
-  const handleSuccess = async (result, command3, usageMeter) => {
+var reviewCommand = new Command("review").description("Review a GitHub pull request or local changes").option("--pr <pr>", "The pull request number or URL to review").option("--json", "Output the review in JSON format", false).option("-y, --yes", "Automatically apply review feedback", false).option("--loop [count]", "Re-review after changes are applied.", (value) => {
+  if (value === undefined || value === null) {
+    return 1;
+  }
+  const parsedValue = parseInt(value, 10);
+  if (Number.isNaN(parsedValue) || parsedValue < 1) {
+    throw new InvalidOptionArgumentError("Must be a positive number.");
+  }
+  return parsedValue;
+}, 1).action(async (options, command2) => {
+  const { json: json2, pr: pr2, loop: maxIterations, yes: yesOption } = options;
+  const yes = maxIterations > 1 || yesOption;
+  let usageMeter;
+  let changesAppliedInThisIteration = false;
+  const handleSuccess = async (result, cmd, um) => {
+    if (um) {
+      if (usageMeter) {
+        usageMeter.merge(um);
+      } else {
+        usageMeter = um;
+      }
+    }
     if (result.type === "success" && result.output.shouldRunTask) {
-      _willRunTask = true;
-      if (!command3) {
+      changesAppliedInThisIteration = true;
+      if (!cmd) {
         throw new Error("Command object not available in handleSuccess");
       }
       const taskInstruction = `please address the review result:
 
 ${result.output.formattedReview}`;
-      await runTask(taskInstruction, {}, command3, {
+      await runTask(taskInstruction, {}, cmd, {
         externalUsageMeter: usageMeter,
-        suppressUsagePrint: false
+        suppressUsagePrint: true
       });
-    } else if (usageMeter && !json2) {
-      usageMeter.printUsage();
     }
   };
-  await runWorkflowCommand("review", reviewWorkflow, command2, input, handleSuccess, {
-    json: json2,
-    suppressUsagePrint: true
-  });
+  for (let i = 0;i < maxIterations; i++) {
+    changesAppliedInThisIteration = false;
+    const input = { json: json2, ...pr2 && { pr: pr2 }, yes };
+    if (i > 0) {
+      command2.opts().silent || console.log(`
+Re-running review (iteration ${i + 1} of ${maxIterations})...`);
+    }
+    await runWorkflowCommand("review", reviewWorkflow, command2, input, handleSuccess, {
+      json: json2,
+      suppressUsagePrint: true
+    });
+    if (maxIterations > 1 && !changesAppliedInThisIteration) {
+      command2.opts().silent || console.log(`
+No more review feedback to apply. Exiting loop.`);
+      break;
+    }
+  }
+  if (usageMeter && !json2) {
+    usageMeter.printUsage();
+  }
 });
 
 // src/index.ts

package/package.json

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