@polka-codes/cli-shared 0.9.33 → 0.9.35

package/dist/index.js

@@ -38267,10 +38267,10 @@ class UsageMeter {
     };
     const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
     const result = this.#calculageUsage(usage, resp.providerMetadata, modelInfo);
-    this.#totals.input += result.input;
-    this.#totals.output += result.output;
-    this.#totals.cachedRead += result.cachedRead;
-    this.#totals.cost += result.cost;
+    this.#totals.input += result.input || 0;
+    this.#totals.output += result.output || 0;
+    this.#totals.cachedRead += result.cachedRead || 0;
+    this.#totals.cost += result.cost || 0;
     this.#totals.messageCount += 1;
   }
   setUsage(newUsage) {
@@ -46072,13 +46072,6 @@ 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,
@@ -46370,519 +46363,6 @@ 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 [key, value] of Object.entries(defaultHeaders)) {
@@ -51671,189 +51151,8 @@ var createNewProject_default = {
   agent: "architect"
 };
 
-// ../core/src/AiTool/generateGitCommitMessage.ts
-var prompt2 = `
-You are an advanced assistant specialized in creating concise and accurate Git commit messages. When you receive:
-- A Git diff inside the <tool_input> tag.
-- Additional user-supplied context inside the <tool_input_context> tag (if any).
-
-You will produce a single commit message enclosed within <tool_output> tags. The commit message must accurately reflect the changes shown in the diff and should be clear, descriptive, and devoid of unnecessary or repeated information. If a context is provided, it MUST be incorporated into the commit message.
-
-Here’s an example of the input and the expected output format:
-
-<tool_input>
---- a/example_file.py
-+++ b/example_file.py
-@@ -10,7 +10,7 @@ def example_function():
--    print("Old behavior")
-+    print("New behavior")
-</tool_input>
-<tool_input_context>
-Changing print statement to update the user-facing message.
-</tool_input_context>
-
-Example Output:
-
-<tool_output>
-Update print statement for revised user-facing message
-</tool_output>
-
-Follow the same structure for any new input. Never repeat questions; focus on generating a concise commit message that captures the essence of the changes.
-`;
-var generateGitCommitMessage_default = {
-  name: "generateGitCommitMessage",
-  description: "Generates git commit messages from git diff output",
-  prompt: prompt2,
-  formatInput: (params) => {
-    let ret = `<tool_input>
-${params.diff}
-</tool_input>`;
-    if (params.context) {
-      ret += `
-<tool_input_context>
-${params.context}
-</tool_input_context>`;
-    }
-    return ret;
-  },
-  parseOutput: (output) => {
-    const regex = /<tool_output>([\s\S]*)<\/tool_output>/gm;
-    const match = regex.exec(output);
-    if (match) {
-      return match[1];
-    }
-    throw new Error(`Could not parse output:
-${output}`);
-  }
-};
-
-// ../core/src/AiTool/generateGithubPullRequestDetails.ts
-var prompt3 = `
-# Generate Github Pull Request Details
-
-You are given:
-- A branch name in <tool_input_branch_name>.
-- An optional context message in <tool_input_context> (which may or may not be present).
-- All commit messages combined in <tool_input_commit_messages>.
-- All diffs combined in <tool_input_commit_diff>.
-
-Your task:
-1. Consider the optional context (if provided).
-   - If an issue number is found, add "Closes #xxx" at the beginning of the PR description
-   - IMPORTANT: Use ONLY the exact format "Closes #xxx" at the beginning of the description
-   - DO NOT use variations like "Closes issue #xxx" or other formats
-2. Analyze the combined commit messages and diffs.
-3. Produce a single GitHub Pull Request title.
-4. Produce a Pull Request description that explains the changes.
-
-Use the following template for the Pull Request description:
-
----
-**Context (if provided)**:
-- Acknowledge any guiding concerns or instructions.
-
-**Summary of Changes**:
-- Provide a concise list or overview of what changed.
-
-**Highlights of Changed Code**:
-- Mention only the specific sections or functionalities updated, without showing full surrounding context.
-
-**Additional Information (if needed)**:
-- Testing steps (if applicable).
-- Any notes or caveats.
-
----
-
-Output format:
-<tool_output>
-  <tool_output_pr_title>YOUR PR TITLE HERE</tool_output_pr_title>
-  <tool_output_pr_description>
-    YOUR PR DESCRIPTION HERE
-  </tool_output_pr_description>
-</tool_output>
-
-Below is an **example** of the input and output:
-
-Example Input:
-<tool_input>
-<tool_input_branch_name>feature/refactor-logging</tool_input_branch_name>
-<tool_input_context>Implementing changes for issue #123 - Focus on clean code and maintainability</tool_input_context>
-<tool_input_commit_messages>
-Remove debug logs
-Refactor order validation logic
-</tool_input_commit_messages>
-<tool_input_commit_diff>
-diff --git a/user_service.py b/user_service.py
-- print("Debug info")
-+ # Removed debug print statements
-
-diff --git a/order_service.py b/order_service.py
-- if is_valid_order(order):
--     process_order(order)
-+ validate_and_process(order)
-</tool_input_commit_diff>
-</tool_input>
-
-Example Output:
-<tool_output>
-<tool_output_pr_title>Refactor Order Validation and Remove Debug Logs</tool_output_pr_title>
-<tool_output_pr_description>
-Closes #123
-
-**Context**:
-- Implementing changes for issue #123 - Focus on clean code and maintainability
-
-**Summary of Changes**:
-- Refactored order validation logic to use a new \`validate_and_process\` method.
-- Removed debug print statements from \`user_service.py\`.
-
-**Highlights of Changed Code**:
-- \`order_service.py\`: Replaced direct call to \`process_order\` with \`validate_and_process\`.
-- \`user_service.py\`: Removed \`print("Debug info")\`.
-</tool_output_pr_description>
-</tool_output>
-
----
-
-Use the above format whenever you receive <tool_input> that may include a branch name, an optional context, aggregated commit messages in a single tag, and a combined diff in a single tag. Provide your final output strictly in <tool_output> with <tool_output_pr_title> and <tool_output_pr_description>. Only highlight the changed code and avoid including the context around the changes in the description.
-`;
-var generateGithubPullRequestDetails_default = {
-  name: "generateGithubPullRequestDetails",
-  description: "Generates a GitHub pull request title and description from git commits",
-  prompt: prompt3,
-  formatInput: (params) => {
-    return `<tool_input>
-<tool_input_branch_name>${params.branchName}</tool_input_branch_name>${params.context ? `
-<tool_input_context>${params.context}</tool_input_context>` : ""}
-<tool_input_commit_messages>${params.commitMessages}</tool_input_commit_messages>
-<tool_input_commit_diff>${params.commitDiff}</tool_input_commit_diff>
-</tool_input>`;
-  },
-  parseOutput: (output) => {
-    const regex = /<tool_output>([\s\S]*)<\/tool_output>/gm;
-    const match = regex.exec(output);
-    if (!match) {
-      throw new Error(`Could not parse output:
-${output}`);
-    }
-    const [, outputContent] = match;
-    const titleRegex = /<tool_output_pr_title>([\s\S]*)<\/tool_output_pr_title>/gm;
-    const titleMatch = titleRegex.exec(outputContent);
-    const descriptionRegex = /<tool_output_pr_description>([\s\S]*)<\/tool_output_pr_description>/gm;
-    const descriptionMatch = descriptionRegex.exec(outputContent);
-    if (titleMatch && descriptionMatch) {
-      return {
-        title: titleMatch[1],
-        description: descriptionMatch[1]
-      };
-    }
-    throw new Error(`Could not parse output:
-${output}`);
-  }
-};
-
 // ../core/src/AiTool/generateProjectConfig.ts
-var prompt4 = `
+var prompt2 = `
 Role: Analyzer agent
 Goal: Produce a valid polkacodes YAML configuration for the project.
 
@@ -51900,7 +51199,7 @@ excludeFiles:     # only files likely to hold secrets
 var generateProjectConfig_default = {
   name: "generateProjectConfig",
   description: "Analyzes project files to generate polkacodes config sections",
-  prompt: prompt4,
+  prompt: prompt2,
   formatInput: () => {
     return "";
   },
@@ -51911,21 +51210,6 @@ var generateProjectConfig_default = {
 };
 
 // ../core/src/AiTool/index.ts
-var executeTool2 = async (definition, ai, params, usageMeter) => {
-  const resp = await generateText({
-    model: ai,
-    temperature: 0,
-    system: definition.prompt,
-    messages: [
-      {
-        role: "user",
-        content: definition.formatInput(params)
-      }
-    ]
-  });
-  usageMeter.addUsage(ai, resp);
-  return definition.parseOutput(resp.text);
-};
 var executeMultiAgentTool = async (definition, agent, params) => {
   const exitReason = await agent.startTask({
     agentName: definition.agent,
@@ -51937,18 +51221,11 @@ var executeMultiAgentTool = async (definition, agent, params) => {
   }
   throw new Error(`Tool execution failed: ${exitReason.type}`);
 };
-var makeTool = (definition) => {
-  return async (ai, params, usageMeter) => {
-    return executeTool2(definition, ai, params, usageMeter);
-  };
-};
 var makeMultiAgentTool = (definition) => {
   return async (agent, params) => {
     return executeMultiAgentTool(definition, agent, params);
   };
 };
-var generateGitCommitMessage = makeTool(generateGitCommitMessage_default);
-var generateGithubPullRequestDetails = makeTool(generateGithubPullRequestDetails_default);
 var generateProjectConfig = makeMultiAgentTool(generateProjectConfig_default);
 var createNewProject = makeMultiAgentTool(createNewProject_default);
 // ../core/src/workflow/utils.ts
@@ -56875,11 +56152,11 @@ class ScreenManager {
   render(content, bottomContent = "") {
     const promptLine = lastLine(content);
     const rawPromptLine = stripVTControlCharacters(promptLine);
-    let prompt5 = rawPromptLine;
+    let prompt3 = rawPromptLine;
     if (this.rl.line.length > 0) {
-      prompt5 = prompt5.slice(0, -this.rl.line.length);
+      prompt3 = prompt3.slice(0, -this.rl.line.length);
     }
-    this.rl.setPrompt(prompt5);
+    this.rl.setPrompt(prompt3);
     this.cursorPos = this.rl.getCursorPos();
     const width = readlineWidth();
     content = breakLines(content, width);
@@ -56949,7 +56226,7 @@ function getCallSites() {
 }
 function createPrompt(view) {
   const callSites = getCallSites();
-  const prompt5 = (config3, context = {}) => {
+  const prompt3 = (config3, context = {}) => {
     const { input = process.stdin, signal } = context;
     const cleanups = new Set;
     const output = new import_mute_stream.default;
@@ -57014,7 +56291,7 @@ function createPrompt(view) {
       }).then(() => promise2), { cancel });
     });
   };
-  return prompt5;
+  return prompt3;
 }
 // ../../node_modules/@inquirer/core/dist/esm/lib/Separator.js
 var import_yoctocolors_cjs2 = __toESM(require_yoctocolors_cjs(), 1);

package/package.json

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