@polka-codes/cli 0.10.21 → 0.10.23

package/dist/chunk-FSNPWI3C.js

@@ -1,128 +0,0 @@
-import {
-  UserCancelledError
-} from "./chunk-LLMPMGV3.js";
-import {
-  gitDiff_default
-} from "./chunk-UEEU3SCC.js";
-import {
-  COMMIT_MESSAGE_SYSTEM_PROMPT,
-  parseGitDiffNameStatus
-} from "./chunk-2LRQ2QH6.js";
-
-// src/workflows/commit.workflow.ts
-import { agentWorkflow, listFiles, readBinaryFile, readFile, searchFiles } from "@polka-codes/core";
-import { z } from "zod";
-var commitWorkflow = async (input, context) => {
-  const { step, tools, logger } = context;
-  const { stagedFiles, unstagedFiles } = await tools.printChangeFile();
-  let hasStaged = stagedFiles.length > 0;
-  const hasUnstaged = unstagedFiles.length > 0;
-  if (input.files && input.files.length > 0) {
-    await step("stage-files", async () => {
-      const result2 = await tools.executeCommand({
-        command: "git",
-        args: ["add", ...input.files ?? []]
-      });
-      if (result2.exitCode !== 0) {
-        throw new Error(`Failed to stage files: ${result2.stderr}`);
-      }
-    });
-    hasStaged = true;
-  } else if (!hasStaged) {
-    if (input.all) {
-      await step("stage-all", async () => {
-        const result2 = await tools.executeCommand({ command: "git", args: ["add", "."] });
-        if (result2.exitCode !== 0) {
-          throw new Error(`Failed to stage files: ${result2.stderr}`);
-        }
-      });
-      hasStaged = true;
-    } else if (hasUnstaged) {
-      let confirmed = false;
-      if (input.interactive !== false) {
-        confirmed = await tools.confirm({
-          message: "No staged files found. Stage all files?",
-          default: false
-        });
-      }
-      if (confirmed) {
-        await step("stage-all", async () => {
-          const result2 = await tools.executeCommand({
-            command: "git",
-            args: ["add", "."]
-          });
-          if (result2.exitCode !== 0) {
-            throw new Error(`Failed to stage files: ${result2.stderr}`);
-          }
-        });
-        hasStaged = true;
-      } else if (input.interactive !== false) {
-        throw new UserCancelledError();
-      }
-    }
-  }
-  if (!hasStaged) {
-    throw new Error("No files to commit. Aborting.");
-  }
-  const { changedFiles, diff } = await step("get-diff", async () => {
-    let changedFiles2 = [];
-    const diffNameStatusResult = await tools.executeCommand({
-      command: "git",
-      args: ["diff", "--name-status", "--no-color", "--staged"]
-    });
-    if (diffNameStatusResult.exitCode === 0) {
-      changedFiles2 = parseGitDiffNameStatus(diffNameStatusResult.stdout);
-    }
-    const diffResult = await tools.executeCommand({
-      command: "git",
-      args: ["diff", "--staged"]
-    });
-    const diff2 = diffResult.stdout;
-    return { changedFiles: changedFiles2, diff: diff2 };
-  });
-  const fileList = changedFiles.map((file) => `${file.status}: ${file.path}`).join("\n");
-  const fileListPrompt = `<file_status>
-${fileList}
-</file_status>`;
-  const diffPrompt = `<diff>
-${diff}
-</diff>`;
-  const contextPrompt = input.context ? `
-<tool_input_context>
-${input.context}
-</tool_input_context>` : "";
-  const commitMessageSchema = z.object({
-    commitMessage: z.string()
-  });
-  const result = await step("generate-commit-message", async () => {
-    return await agentWorkflow(
-      {
-        systemPrompt: COMMIT_MESSAGE_SYSTEM_PROMPT,
-        userMessage: [
-          {
-            role: "user",
-            content: `${fileListPrompt}${diffPrompt}${contextPrompt}`
-          }
-        ],
-        tools: [readFile, readBinaryFile, searchFiles, listFiles, gitDiff_default],
-        outputSchema: commitMessageSchema
-      },
-      context
-    );
-  });
-  if (result.type === "Exit" && result.object) {
-    const { commitMessage } = commitMessageSchema.parse(result.object);
-    if (commitMessage) {
-      logger.info(`
-Commit message:
-${commitMessage}`);
-      await tools.createCommit({ message: commitMessage });
-      return commitMessage;
-    }
-  }
-  context.logger.warn("Failed to generate commit message.", result);
-};
-
-export {
-  commitWorkflow
-};

package/dist/chunk-HB7PTE3H.js

@@ -1,176 +0,0 @@
-import {
-  fixWorkflow
-} from "./chunk-ZS4K5RFU.js";
-import {
-  planWorkflow
-} from "./chunk-YPUL66UK.js";
-import {
-  getCoderSystemPrompt,
-  getDefaultContext,
-  getImplementPrompt
-} from "./chunk-2LRQ2QH6.js";
-
-// src/workflows/code.workflow.ts
-import {
-  agentWorkflow,
-  askFollowupQuestion,
-  executeCommand,
-  fetchUrl,
-  listFiles,
-  readBinaryFile,
-  readFile,
-  removeFile,
-  renameFile,
-  replaceInFile,
-  searchFiles,
-  writeToFile
-} from "@polka-codes/core";
-import { z } from "zod";
-var ImplementOutputSchema = z.object({
-  summary: z.string().nullish().describe("Short summary of the changes made"),
-  bailReason: z.string().nullish().describe("Reason for bailing out of the implementation loop")
-}).refine((data) => data.summary != null !== (data.bailReason != null), {
-  message: "Either summary or bailReason must be provided, but not both"
-});
-var codeWorkflow = async (input, context) => {
-  const { logger, step, tools } = context;
-  const { task, files, mode: inputMode, customTools, additionalInstructions, interactive, additionalTools } = input;
-  const mode = interactive === false ? "noninteractive" : inputMode ?? "interactive";
-  const summaries = [];
-  logger.info("\nPhase 1: Creating implementation plan...\n");
-  const planResult = await step("plan", async () => {
-    return await planWorkflow(
-      { task, files, mode: mode === "interactive" ? "confirm" : "noninteractive", interactive, additionalTools },
-      context
-    );
-  });
-  if (!planResult) {
-    logger.info("Plan not approved. Exiting.");
-    return { success: false, reason: "Plan not approved", summaries };
-  }
-  const { plan, files: planFiles } = planResult;
-  logger.info("\nPhase 2: Implementing the plan...\n");
-  let implementPrompt = getImplementPrompt(plan);
-  if (planFiles && planFiles.length > 0) {
-    const fileContentString = planFiles.map((f) => `<file path="${f.path}">${f.content}</file>`).join("\n");
-    implementPrompt += `
-
-Here are the files related to the plan:
-${fileContentString}`;
-  }
-  const userContent = [{ type: "text", text: implementPrompt }];
-  if (files) {
-    for (const file of files) {
-      if (file.type === "file") {
-        userContent.push({
-          type: "file",
-          mediaType: file.mediaType,
-          filename: file.filename,
-          data: { type: "base64", value: file.data }
-        });
-      } else if (file.type === "image") {
-        userContent.push({
-          type: "image",
-          mediaType: file.mediaType,
-          image: { type: "base64", value: file.image }
-        });
-      }
-    }
-  }
-  const agentTools = [
-    readFile,
-    writeToFile,
-    replaceInFile,
-    searchFiles,
-    listFiles,
-    executeCommand,
-    fetchUrl,
-    readBinaryFile,
-    removeFile,
-    renameFile
-  ];
-  if (mode === "interactive") {
-    agentTools.push(askFollowupQuestion);
-  }
-  if (customTools) {
-    agentTools.push(...customTools);
-  }
-  if (additionalTools?.search) {
-    agentTools.push(additionalTools.search);
-  }
-  if (additionalTools?.mcpTools) {
-    agentTools.push(...additionalTools.mcpTools);
-  }
-  const res = await step("implement", async () => {
-    const { context: defaultContext, loadRules } = await getDefaultContext(input.config, "code");
-    const memoryContext = await tools.getMemoryContext();
-    const textContent = userContent.find((c) => c.type === "text");
-    if (textContent && textContent.type === "text") {
-      textContent.text = `${textContent.text}
-
-${defaultContext}
-${memoryContext}`;
-    } else {
-      userContent.push({
-        type: "text",
-        text: `${defaultContext}
-${memoryContext}`
-      });
-    }
-    const baseSystemPrompt = getCoderSystemPrompt(loadRules);
-    const systemPrompt = additionalInstructions ? `${baseSystemPrompt}
-
-${additionalInstructions}` : baseSystemPrompt;
-    return await agentWorkflow(
-      {
-        systemPrompt,
-        userMessage: [{ role: "user", content: userContent }],
-        tools: agentTools,
-        outputSchema: ImplementOutputSchema
-      },
-      context
-    );
-  });
-  if (res.type === "Exit" && res.object) {
-    const { summary, bailReason } = res.object;
-    if (bailReason) {
-      logger.error(`
-Implementation failed: ${bailReason}
-`);
-      return { success: false, reason: bailReason, summaries };
-    }
-    if (summary) {
-      logger.info("\nImplementation complete!\n");
-      summaries.push(summary);
-      logger.info(`Summary: ${summary}`);
-      await step("summarize-implementation", async () => {
-        await tools.updateMemory({
-          operation: "append",
-          topic: "implementation-summary",
-          content: summary
-        });
-      });
-    } else {
-      logger.info("\nImplementation complete!\n");
-    }
-  } else if (res.type === "Exit") {
-    logger.info("\nImplementation complete!\n");
-  } else {
-    logger.warn("\nWarning: Implementation failed. Please check the output for errors.\n", res);
-  }
-  logger.info("\nPhase 3: Checking for errors...\n");
-  const fixResult = await step("fix", async () => {
-    return await fixWorkflow({ interactive: false, task: input.task, additionalTools: input.additionalTools }, context);
-  });
-  if (fixResult.summaries) {
-    summaries.push(...fixResult.summaries);
-  }
-  if (!fixResult.success) {
-    return { success: false, reason: fixResult.reason, summaries };
-  }
-  return { success: true, summaries };
-};
-
-export {
-  codeWorkflow
-};

package/dist/chunk-LLMPMGV3.js

@@ -1,140 +0,0 @@
-// src/errors.ts
-import { createErrorClass } from "@polka-codes/core";
-var UserCancelledError = createErrorClass("UserCancelledError", (args) => args[0] ?? "User cancelled");
-var ProviderError = class extends Error {
-  provider;
-  model;
-  retryable;
-  cause;
-  constructor(provider, model, message, retryable, cause) {
-    super(message);
-    this.name = this.constructor.name;
-    this.provider = provider;
-    this.model = model;
-    this.retryable = retryable;
-    this.cause = cause;
-  }
-};
-var ProviderUnavailableError = class extends ProviderError {
-  constructor(provider, model, statusCode, cause) {
-    super(
-      provider,
-      model,
-      `${provider} API is temporarily unavailable (HTTP ${statusCode}). The service may be experiencing issues. Please try again in a few minutes.`,
-      true,
-      cause
-    );
-  }
-};
-var RateLimitError = class extends ProviderError {
-  retryAfter;
-  constructor(provider, model, retryAfter, cause) {
-    const message = retryAfter ? `${provider} rate limit exceeded. Please retry after ${retryAfter} seconds.` : `${provider} rate limit exceeded. Please wait a few minutes before retrying.`;
-    super(provider, model, message, true, cause);
-    this.retryAfter = retryAfter;
-  }
-};
-var ProviderTimeoutError = class extends ProviderError {
-  timeoutSeconds;
-  constructor(provider, model, timeoutSeconds, cause) {
-    super(
-      provider,
-      model,
-      `${provider} request timed out after ${timeoutSeconds} seconds. This could be due to network issues or the service being slow. Please check your connection and try again.`,
-      true,
-      cause
-    );
-    this.timeoutSeconds = timeoutSeconds;
-  }
-};
-var AuthenticationError = class extends ProviderError {
-  constructor(provider, model, cause) {
-    super(
-      provider,
-      model,
-      `${provider} authentication failed for model '${model}'. Please check your API key is valid and has not expired. Run 'polka init' to reconfigure.`,
-      false,
-      cause
-    );
-  }
-};
-var ModelAccessError = class extends ProviderError {
-  constructor(provider, model, statusCode, cause) {
-    super(
-      provider,
-      model,
-      `${provider} model '${model}' is not available (HTTP ${statusCode}). This could mean the model doesn't exist, you don't have access, or it's not enabled in your account. Please check your model configuration.`,
-      false,
-      cause
-    );
-  }
-};
-var InvalidRequestError = class extends ProviderError {
-  constructor(provider, model, details, cause) {
-    super(
-      provider,
-      model,
-      `${provider} rejected the request: ${details}. Please check your request parameters and try again.`,
-      false,
-      cause
-    );
-  }
-};
-var QuotaExceededError = class extends ProviderError {
-  currentCost;
-  maxCost;
-  constructor(provider, model, currentCost, maxCost) {
-    super(
-      provider,
-      model,
-      `${provider} quota exceeded for model '${model}'. Current cost: $${currentCost.toFixed(2)}, Max budget: $${maxCost.toFixed(2)}. Adjust your budget with 'polka init' or reduce usage.`,
-      false
-    );
-    this.currentCost = currentCost;
-    this.maxCost = maxCost;
-  }
-};
-var MaxRetriesExceededError = class extends ProviderError {
-  attempts;
-  lastError;
-  constructor(provider, model, attempts, lastError) {
-    super(
-      provider,
-      model,
-      `${provider} failed after ${attempts} retry attempts for model '${model}'. Last error: ${lastError.message}. Please check your network connection and verify the service is operational.`,
-      false,
-      lastError
-    );
-    this.attempts = attempts;
-    this.lastError = lastError;
-  }
-};
-function createProviderErrorFromStatus(provider, model, statusCode, cause) {
-  switch (statusCode) {
-    case 400:
-      return new InvalidRequestError(provider, model, "Bad request", cause);
-    case 401:
-      return new AuthenticationError(provider, model, cause);
-    case 403:
-    case 404:
-      return new ModelAccessError(provider, model, statusCode, cause);
-    case 429:
-      return new RateLimitError(provider, model, void 0, cause);
-    default:
-      if (statusCode >= 500) {
-        return new ProviderUnavailableError(provider, model, statusCode, cause);
-      }
-      return new InvalidRequestError(provider, model, `HTTP ${statusCode}`, cause);
-  }
-}
-
-export {
-  UserCancelledError,
-  ProviderError,
-  ProviderTimeoutError,
-  AuthenticationError,
-  ModelAccessError,
-  QuotaExceededError,
-  MaxRetriesExceededError,
-  createProviderErrorFromStatus
-};