@polka-codes/cli 0.10.21 → 0.10.23

package/dist/chunk-UEEU3SCC.js

@@ -1,390 +0,0 @@
-// src/tools/gitDiff.ts
-import { z } from "zod";
-
-// src/tools/utils/diffLineNumbers.ts
-function parseHunkHeader(header) {
-  const match = header.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-  if (!match) return null;
-  return {
-    oldStart: parseInt(match[1], 10),
-    oldCount: match[2] ? parseInt(match[2], 10) : 1,
-    newStart: parseInt(match[3], 10),
-    newCount: match[4] ? parseInt(match[4], 10) : 1,
-    header
-  };
-}
-function annotateDiffWithLineNumbers(diff) {
-  const lines = diff.split("\n");
-  const annotatedLines = [];
-  let currentNewLine = 0;
-  let currentOldLine = 0;
-  let inHunk = false;
-  for (const line of lines) {
-    if (line.startsWith("@@")) {
-      const hunk = parseHunkHeader(line);
-      if (hunk) {
-        currentOldLine = hunk.oldStart;
-        currentNewLine = hunk.newStart;
-        inHunk = true;
-      }
-      annotatedLines.push(line);
-      continue;
-    }
-    if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++")) {
-      annotatedLines.push(line);
-      inHunk = false;
-      continue;
-    }
-    if (!inHunk) {
-      annotatedLines.push(line);
-      continue;
-    }
-    if (line.startsWith("+") && !line.startsWith("+++")) {
-      annotatedLines.push(`${line} [Line ${currentNewLine}]`);
-      currentNewLine++;
-    } else if (line.startsWith("-") && !line.startsWith("---")) {
-      annotatedLines.push(`${line} [Line ${currentOldLine} removed]`);
-      currentOldLine++;
-    } else if (line.startsWith(" ")) {
-      annotatedLines.push(line);
-      currentOldLine++;
-      currentNewLine++;
-    } else {
-      annotatedLines.push(line);
-    }
-  }
-  return annotatedLines.join("\n");
-}
-
-// src/tools/gitDiff.ts
-var toolInfo = {
-  name: "git_diff",
-  description: "Get the git diff for the current repository. Can be used to get staged changes, unstaged changes, or changes between commits. By default, it returns unstaged changes.",
-  parameters: z.object({
-    staged: z.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z.boolean().optional().default(false)).describe("Get staged changes instead of unstaged changes."),
-    commitRange: z.string().optional().describe('The commit range to get the diff for (e.g., "main...HEAD").'),
-    file: z.string().describe("Get the diff for a specific file."),
-    contextLines: z.coerce.number().optional().default(5).describe("Number of context lines to include around changes."),
-    includeLineNumbers: z.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z.boolean().optional().default(true)).describe("Annotate the diff with line numbers for additions and deletions.")
-  })
-};
-var handler = async (provider, args) => {
-  if (!provider.executeCommand) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to execute command. Abort."
-      }
-    };
-  }
-  const { staged, file, commitRange, contextLines, includeLineNumbers } = toolInfo.parameters.parse(args);
-  const commandParts = ["git", "diff", "--no-color", `-U${contextLines}`];
-  if (staged) {
-    commandParts.push("--staged");
-  }
-  if (commitRange) {
-    commandParts.push(commitRange);
-  }
-  if (file) {
-    const escapedFile = file.replace(/'/g, "'\\''");
-    commandParts.push("--", `'${escapedFile}'`);
-  }
-  const command = commandParts.join(" ");
-  try {
-    const result = await provider.executeCommand(command, false);
-    if (result.exitCode === 0) {
-      if (!result.stdout.trim()) {
-        return {
-          success: true,
-          message: {
-            type: "text",
-            value: "No diff found."
-          }
-        };
-      }
-      let diffOutput = result.stdout;
-      if (includeLineNumbers) {
-        diffOutput = annotateDiffWithLineNumbers(diffOutput);
-      }
-      return {
-        success: true,
-        message: {
-          type: "text",
-          value: `<diff file="${file ?? "all"}">
-${diffOutput}
-</diff>`
-        }
-      };
-    }
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `\`${command}\` exited with code ${result.exitCode}:
-${result.stderr}`
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: error instanceof Error ? error.message : String(error)
-      }
-    };
-  }
-};
-var gitDiff_default = {
-  ...toolInfo,
-  handler
-};
-
-// src/tools/getTodoItem.ts
-import { z as z2 } from "zod";
-var toolInfo2 = {
-  name: "getTodoItem",
-  description: "Get a to-do item by its ID.",
-  parameters: z2.object({
-    id: z2.string().describe("The ID of the to-do item.")
-  })
-};
-var handler2 = async (provider, args) => {
-  if (!provider.getTodoItem) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to get a to-do item."
-      }
-    };
-  }
-  const { id } = toolInfo2.parameters.parse(args);
-  const item = await provider.getTodoItem(id);
-  return {
-    success: true,
-    message: {
-      type: "json",
-      value: item ?? null
-    }
-  };
-};
-var getTodoItem_default = {
-  ...toolInfo2,
-  handler: handler2
-};
-
-// src/tools/listMemoryTopics.ts
-import { z as z3 } from "zod";
-var toolInfo3 = {
-  name: "listMemoryTopics",
-  description: "Lists all topics in memory. Use this to see what information has been stored and which topics are available to read from.",
-  parameters: z3.object({})
-};
-var handler3 = async (provider, _args) => {
-  const topics = await provider.listMemoryTopics();
-  if (!topics.length) {
-    return { success: true, message: { type: "text", value: "No topics found." } };
-  }
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `Memory topics:
-${topics.join("\n")}`
-    }
-  };
-};
-var listMemoryTopics_default = {
-  ...toolInfo3,
-  handler: handler3
-};
-
-// src/tools/listTodoItems.ts
-import { TodoStatus } from "@polka-codes/core";
-import { z as z4 } from "zod";
-var toolInfo4 = {
-  name: "listTodoItems",
-  description: "List all to-do items, sorted by id. If an id is provided, it lists all sub-items for that id. Can be filtered by status.",
-  parameters: z4.object({
-    id: z4.string().nullish(),
-    status: TodoStatus.nullish()
-  })
-};
-var handler4 = async (provider, args) => {
-  if (!provider.listTodoItems) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to list to-do items."
-      }
-    };
-  }
-  const { id, status } = toolInfo4.parameters.parse(args);
-  const items = await provider.listTodoItems(id, status);
-  return {
-    success: true,
-    message: {
-      type: "json",
-      value: items
-    }
-  };
-};
-var listTodoItems_default = {
-  ...toolInfo4,
-  handler: handler4
-};
-
-// src/tools/readMemory.ts
-import { z as z5 } from "zod";
-var toolInfo5 = {
-  name: "readMemory",
-  description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.",
-  parameters: z5.object({
-    topic: z5.string().nullish().describe('The topic to read from memory. Defaults to ":default:".')
-  })
-};
-var handler5 = async (provider, args) => {
-  const { topic } = toolInfo5.parameters.parse(args);
-  const content = await provider.readMemory(topic ?? void 0);
-  if (content) {
-    return {
-      success: true,
-      message: {
-        type: "text",
-        value: `<memory${topic ? ` topic="${topic}"` : ""}>
-${content}
-</memory>`
-      }
-    };
-  }
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `<memory ${topic ? `topic="${topic}"` : ""} isEmpty="true" />`
-    }
-  };
-};
-var readMemory_default = {
-  ...toolInfo5,
-  handler: handler5
-};
-
-// src/tools/updateMemory.ts
-import { z as z6 } from "zod";
-var toolInfo6 = {
-  name: "updateMemory",
-  description: 'Appends, replaces, or removes content from a memory topic. Use "append" to add to existing content, "replace" to overwrite entirely, or "remove" to delete a topic. Memory persists across tool calls within a workflow.',
-  parameters: z6.object({
-    operation: z6.enum(["append", "replace", "remove"]).describe("The operation to perform."),
-    topic: z6.string().nullish().describe('The topic to update in memory. Defaults to ":default:".'),
-    content: z6.string().nullish().describe("The content for append or replace operations. Must be omitted for remove operation.")
-  }).superRefine((data, ctx) => {
-    if (data.operation === "append" || data.operation === "replace") {
-      if (data.content === void 0) {
-        ctx.addIssue({
-          code: "custom",
-          message: 'Content is required for "append" and "replace" operations.',
-          path: ["content"]
-        });
-      }
-    } else if (data.operation === "remove") {
-      if (data.content !== void 0) {
-        ctx.addIssue({
-          code: "custom",
-          message: 'Content must not be provided for "remove" operation.',
-          path: ["content"]
-        });
-      }
-    }
-  })
-};
-var handler6 = async (provider, args) => {
-  if (!provider.updateMemory) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Memory operations are not supported by the current provider."
-      }
-    };
-  }
-  const params = toolInfo6.parameters.parse(args);
-  await provider.updateMemory(params.operation, params.topic ?? void 0, params.content ?? void 0);
-  const topic = params.topic || ":default:";
-  const messages = {
-    append: `Content appended to memory topic '${topic}'`,
-    replace: `Memory topic '${topic}' replaced`,
-    remove: `Memory topic '${topic}' removed`
-  };
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: messages[params.operation]
-    }
-  };
-};
-var updateMemory_default = {
-  ...toolInfo6,
-  handler: handler6
-};
-
-// src/tools/updateTodoItem.ts
-import { UpdateTodoItemInputSchema } from "@polka-codes/core";
-var toolInfo7 = {
-  name: "updateTodoItem",
-  description: "Add or update a to-do item.",
-  parameters: UpdateTodoItemInputSchema
-};
-var handler7 = async (provider, args) => {
-  if (!provider.updateTodoItem) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to update a to-do item."
-      }
-    };
-  }
-  const input = toolInfo7.parameters.parse(args);
-  const result = await provider.updateTodoItem(input);
-  return {
-    success: true,
-    message: {
-      type: "json",
-      value: result
-    }
-  };
-};
-var updateTodoItem_default = {
-  ...toolInfo7,
-  handler: handler7
-};
-
-export {
-  getTodoItem_default,
-  annotateDiffWithLineNumbers,
-  gitDiff_default,
-  listMemoryTopics_default,
-  listTodoItems_default,
-  readMemory_default,
-  updateMemory_default,
-  updateTodoItem_default
-};

package/dist/chunk-YPUL66UK.js

@@ -1,277 +0,0 @@
-import {
-  UserCancelledError
-} from "./chunk-LLMPMGV3.js";
-import {
-  PlanSchema,
-  getDefaultContext,
-  getPlanPrompt,
-  getPlannerSystemPrompt
-} from "./chunk-2LRQ2QH6.js";
-
-// src/workflows/plan.workflow.ts
-import {
-  agentWorkflow,
-  askFollowupQuestion,
-  fetchUrl,
-  listFiles,
-  readBinaryFile,
-  readFile,
-  searchFiles
-} from "@polka-codes/core";
-async function createPlan(input, context) {
-  const { tools, step } = context;
-  const { task, files, plan: inputPlan, userFeedback, interactive, messages, additionalTools } = input;
-  const getMessages = async () => {
-    if (messages) {
-      return {
-        messages,
-        userMessage: [{ role: "user", content: userFeedback ?? task }]
-      };
-    } else {
-      const { context: defaultContext, loadRules } = await getDefaultContext(input.config, "plan");
-      const memoryContext = await tools.getMemoryContext();
-      const prompt = `${memoryContext}
-${getPlanPrompt(task, inputPlan)}
-
-${defaultContext}`;
-      const userContent = [{ type: "text", text: prompt }];
-      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 }
-            });
-          }
-        }
-      }
-      return {
-        systemPrompt: getPlannerSystemPrompt(loadRules),
-        userMessage: [{ role: "user", content: userContent }]
-      };
-    }
-  };
-  const agentTools = [readFile, listFiles, searchFiles, readBinaryFile, fetchUrl];
-  if (additionalTools?.search) {
-    agentTools.push(additionalTools.search);
-  }
-  if (additionalTools?.mcpTools) {
-    agentTools.push(...additionalTools.mcpTools);
-  }
-  if (interactive) {
-    agentTools.push(askFollowupQuestion);
-  }
-  const inputMessages = await getMessages();
-  const result = await step("plan", async () => {
-    return await agentWorkflow(
-      {
-        ...inputMessages,
-        tools: agentTools,
-        outputSchema: PlanSchema
-      },
-      context
-    );
-  });
-  if (result.type === "Exit" && result.object) {
-    const { plan, question, reason, files: filePaths } = result.object;
-    if (reason) {
-      return { reason, messages: result.messages };
-    }
-    if (question) {
-      return { plan: plan || inputPlan, question, messages: result.messages };
-    }
-    const outputFiles = [];
-    if (filePaths) {
-      for (const path of filePaths) {
-        const content = await tools.readFile({ path });
-        if (content) {
-          outputFiles.push({ path, content });
-        }
-      }
-    }
-    if (plan) {
-      try {
-        const taskSummary = task.split("\n")[0].substring(0, 100);
-        const topic = `plan:${taskSummary.replace(/[^a-zA-Z0-9_-]+/g, "-").toLowerCase()}`;
-        const keywords = task.toLowerCase().match(/(?:implement|create|add|fix|refactor|update|improve|optimize|test|document)(?:\s+(\w+))?/g);
-        const _tags = keywords ? keywords.map((k) => {
-          const parts = k.split(" ");
-          if (parts.length > 1) {
-            return parts.join("-");
-          }
-          return k;
-        }).join(",") : void 0;
-        await tools.updateMemory({
-          operation: "replace",
-          topic,
-          content: plan
-        });
-        context.logger.info(`Plan saved to memory as: ${topic}`);
-      } catch (error) {
-        context.logger.warn("Failed to save plan to memory:", error);
-      }
-    }
-    return { plan: plan || void 0, files: outputFiles, messages: result.messages };
-  }
-  context.logger.warn("Failed to generate plan.", result);
-  throw new Error("Failed to generate plan.");
-}
-var planWorkflow = async (input, context) => {
-  const { tools, logger, step } = context;
-  const { fileContent, filePath, mode: inputMode, interactive, additionalTools } = input;
-  const mode = interactive === false ? "noninteractive" : inputMode ?? "interactive";
-  let currentTask = input.task;
-  let plan = fileContent || "";
-  let files = [];
-  let userFeedback;
-  let messages;
-  let state = "Generating";
-  let count = 0;
-  while (state !== "Done") {
-    state = await step(`plan-iteration-${count++}`, async () => {
-      switch (state) {
-        case "Generating": {
-          if (!currentTask) {
-            const message = plan ? "How would you like to improve the plan?" : "What is the task you want to plan?";
-            const defaultTask = plan ? "Review and improve the plan" : void 0;
-            try {
-              currentTask = await tools.input({
-                message,
-                default: defaultTask
-              });
-            } catch (_error) {
-              return "Done";
-            }
-          }
-          const planResult = await createPlan(
-            {
-              task: currentTask,
-              plan,
-              userFeedback,
-              files: input.files,
-              interactive: mode === "interactive" || mode === "confirm",
-              messages,
-              additionalTools,
-              config: input.config
-            },
-            context
-          );
-          messages = planResult.messages;
-          if (planResult.reason) {
-            logger.info(planResult.reason);
-            return "Done";
-          }
-          if (planResult.question) {
-            try {
-              userFeedback = await tools.input({
-                message: planResult.question.question,
-                default: planResult.question.defaultAnswer || void 0
-              });
-              plan = planResult.plan || plan;
-              return "Generating";
-            } catch (error) {
-              if (error instanceof UserCancelledError) {
-                throw error;
-              }
-              return "Done";
-            }
-          }
-          plan = planResult.plan || "";
-          files = planResult.files || [];
-          userFeedback = "";
-          return "Reviewing";
-        }
-        case "Reviewing": {
-          logger.info("\nGenerated Plan:\n");
-          logger.info(plan);
-          if (files?.length > 0) {
-            logger.info("\nFiles:");
-            for (const file of files) {
-              logger.info(`- ${file.path}`);
-            }
-          }
-          if (mode === "noninteractive") {
-            return "Done";
-          }
-          if (mode === "confirm") {
-            try {
-              userFeedback = await tools.input({
-                message: "Do you approve this plan and want to proceed with implementation? (leave blank to approve, or enter feedback)"
-              });
-              if (userFeedback === "") {
-                return "Done";
-              } else {
-                return "Generating";
-              }
-            } catch (error) {
-              if (error instanceof UserCancelledError) {
-                throw error;
-              }
-              userFeedback = "";
-              return "Reviewing";
-            }
-          }
-          const choices = [
-            { name: "Save Plan", value: "save" },
-            { name: "Provide Feedback", value: "feedback" },
-            { name: "Regenerate Plan", value: "regenerate" },
-            { name: "Exit", value: "exit" }
-          ];
-          const choice = await tools.select({
-            message: "What do you want to do?",
-            choices
-          });
-          switch (choice) {
-            case "save": {
-              const defaultPath = `.plans/plan-${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.md`;
-              const savePath = filePath || await tools.input({
-                message: "Where do you want to save the plan?",
-                default: defaultPath
-              });
-              await tools.writeToFile({ path: savePath, content: plan });
-              logger.info(`Plan saved to ${savePath}`);
-              return "Done";
-            }
-            case "feedback": {
-              try {
-                userFeedback = await tools.input({
-                  message: "What changes do you want to make?"
-                });
-                return "Generating";
-              } catch (_error) {
-                userFeedback = "";
-                return "Reviewing";
-              }
-            }
-            case "regenerate": {
-              plan = "";
-              userFeedback = "";
-              messages = void 0;
-              return "Generating";
-            }
-            case "exit": {
-              return "Done";
-            }
-            default:
-              throw new Error(`Invalid mode: ${mode}`);
-          }
-        }
-        default:
-          throw new Error(`Invalid state: ${state}`);
-      }
-    });
-  }
-  return { plan, files };
-};
-
-export {
-  planWorkflow
-};