@polka-codes/cli 0.10.21 → 0.10.23

package/dist/chunk-2LRQ2QH6.js

@@ -1,1353 +0,0 @@
-// src/workflows/prompts/shared.ts
-function createJsonResponseInstruction(schema) {
-  return `Respond with a JSON object in a markdown code block matching this schema:
-\`\`\`json
-${JSON.stringify(schema, null, 2)}
-\`\`\`
-`;
-}
-var TOOL_USAGE_INSTRUCTION = `
-## Action Line
-
-Before any tool call, emit a single high-level action line.
-
-You MUST follow these style constraints for the action line:
-- NO filler or preambles.
-- DO NOT use "ok", "okay", "alright".
-- DO NOT use first person ("I", "I'm", "I will", "I'll", etc.).
-- NO apologies, hedging, or promises about later work.
-`;
-var MEMORY_USAGE_SECTION = `## Memory Usage
-
-You have access to a persistent SQLite-based memory store to track information across sessions. This is particularly useful for managing todos, bugs, decisions, and notes.
-
-### Memory Entry Types
-
-Memory entries can be organized by type:
-- **todo**: Task items with status (open/done), priority, and tags
-- **bug**: Bug reports with priority and status
-- **decision**: Architectural decisions and rationale
-- **note**: General notes and documentation
-
-### Todo List Workflow
-
-When working on multi-step tasks, use the memory store to track progress:
-
-**Creating a todo item:**
-Use topic names that clearly describe the task. The content should include the full description.
-
-**Updating todo status:**
-- Mark todos as done when completed
-- Update descriptions as requirements evolve
-- Add tags for organization (e.g., "bug,urgent", "feature,auth")
-
-**Querying todos:**
-- Filter by type: "todo" to see all tasks
-- Filter by status: "open" for pending work
-- Filter by priority: "high" or "critical" for urgent items
-- Search: Find specific todos by keyword
-
-### Best Practices
-
-- **Use descriptive topic names**: "fix-login-bug" is better than "bug-1"
-- **Set appropriate priorities**: Use "critical", "high", "medium", or "low"
-- **Add relevant tags**: Group related items with tags like "auth", "ui", "backend"
-- **Update status regularly**: Mark items as done when completed
-- **Store context**: Include important decisions in memory for future reference
-- **Memory persists**: All stored information is available across sessions in the current project
-
-### Memory Scopes
-
-- **Project scope**: When working in a project directory (with .polkacodes.yml), memory is isolated to that project
-- **Global scope**: When working outside a project, memory is shared globally
-`;
-function AGENTS_INSTRUCTION(loadRules) {
-  const defaultLoadRules = {
-    "AGENTS.md": true,
-    "CLAUDE.md": true
-  };
-  const mergedRules = { ...defaultLoadRules, ...loadRules };
-  const enabledFiles = Object.entries(mergedRules).filter(([, enabled]) => enabled).map(([fileName]) => fileName);
-  if (enabledFiles.length === 0) {
-    return `## Project Instructions
-
-Project-specific instruction files are currently disabled via configuration.`;
-  }
-  const fileList = enabledFiles.join(", ");
-  return `## Project Instructions (${fileList})
-
-If you are working in a subdirectory, check if there is an ${enabledFiles.join(" or ")} file in that directory or parent directories for specific instructions. These files contain project-specific guidelines and conventions that you must follow.
-
-Note: The loading of these files can be controlled via the loadRules configuration option in .polkacodes.yml.
-
-Example:
-\`\`\`yaml
-loadRules:
-  AGENTS.md: true
-  CLAUDE.md: true
-\`\`\`
-`;
-}
-
-// src/workflows/prompts/coder.ts
-function getCoderSystemPrompt(loadRules) {
-  return `Role: AI developer.
-Goal: Implement the provided plan by writing and modifying code.
-
-Your task is to implement the plan created and approved in Phase 1.
-
-${MEMORY_USAGE_SECTION}
-
-${TOOL_USAGE_INSTRUCTION}
-
-${AGENTS_INSTRUCTION(loadRules)}
-
-## Implementation Guidelines
-
-### 1. Plan Analysis
-
-Before starting implementation:
-- Review the plan carefully and understand all requirements
-- Identify dependencies between different parts of the plan
-- Determine if this is a single cohesive task or multiple independent tasks
-- Consider the scope and complexity of the work
-
-### 2. Gather Context
-
-Before making changes:
-- **Search for similar existing files** to understand patterns and conventions
-- **Read relevant files** to see how similar features are implemented
-- Look for existing tests, utilities, or helpers you can leverage
-- Understand the project structure and naming conventions
-- Verify you have all necessary context to proceed
-
-### 3. Implementation Best Practices
-
-- **Make incremental changes**: Implement one piece at a time
-- **Follow existing patterns**: Match the style and structure of similar code
-- **Add documentation**: Include comments explaining complex logic
-- **Consider edge cases**: Think about error handling and boundary conditions
-- **Verify as you go**: Test your changes incrementally if possible
-
-### 4. Code Quality
-
-- Follow the project's existing code style and conventions
-- Use appropriate TypeScript types (avoid 'any' unless necessary)
-- Add JSDoc comments for public APIs and complex functions
-- Ensure proper error handling and validation
-- Keep functions focused and maintainable
-
-## Your Task
-
-Implement the plan above following these guidelines. Start by:
-1. Analyzing the plan structure
-2. Searching for similar existing code patterns
-3. Proceeding with implementation
-
-Please implement all the necessary code changes according to this plan.
-
-After making changes, you MUST return a JSON object in a markdown block with either a summary of the changes OR a bailReason if you cannot complete the task.
-
-DO NOT save this JSON object to a file. Output it directly in your response.
-
-Example for successful implementation:
-${createJsonResponseInstruction({
-    summary: "Implemented user authentication with JWT tokens and password hashing.",
-    bailReason: null
-  })}
-
-Example if unable to implement:
-${createJsonResponseInstruction({
-    summary: null,
-    bailReason: "The plan requires access to external services that are not available in the current environment."
-  })}
-`;
-}
-var CODER_SYSTEM_PROMPT = getCoderSystemPrompt();
-function getImplementPrompt(plan) {
-  return `## Your Plan
-
-<plan>
-${plan}
-</plan>
-`;
-}
-
-// src/workflows/prompts/commit.ts
-var COMMIT_MESSAGE_SYSTEM_PROMPT = `Role: Expert git user.
-Goal: Generate a concise and descriptive commit message in conventional commit format based on staged changes.
-
-${TOOL_USAGE_INSTRUCTION}
-
-You are an expert at writing git commit messages.
-Based on the provided list of staged files in <file_status>, the diff in <diff> and optional user context in <tool_input_context>, generate a concise and descriptive commit message.
-
-Follow the conventional commit format.
-
-${createJsonResponseInstruction({
-  commitMessage: "feat: add new feature\\n\\ndescribe the new feature in more detail"
-})}
-`;
-
-// src/workflows/prompts/fix.ts
-var FIX_SYSTEM_PROMPT = `Role: Expert software developer.
-Goal: Fix a failing command by analyzing the error and modifying the code.
-
-You are an expert software developer. Your task is to fix a project that is failing a command. You have been provided with the failing command, its output (stdout and stderr), and the exit code. Your goal is to use the available tools to modify the files in the project to make the command pass. Analyze the error, inspect the relevant files, and apply the necessary code changes.
-
-${MEMORY_USAGE_SECTION}
-
-${TOOL_USAGE_INSTRUCTION}
-
-After making changes, you MUST return a JSON object in a markdown block with either a summary of the changes OR a bailReason if you cannot complete the task.
-
-DO NOT save this JSON object to a file. Output it directly in your response.
-
-Example for successful fix:
-${createJsonResponseInstruction({
-  summary: "Fixed the 'add' function in 'math.ts' to correctly handle negative numbers.",
-  bailReason: null
-})}
-
-Example if unable to fix:
-${createJsonResponseInstruction({
-  summary: null,
-  bailReason: "Unable to identify the root cause of the error. The error message is ambiguous and requires human investigation."
-})}
-`;
-function getFixUserPrompt(command, exitCode, stdout, stderr, task, prompt) {
-  const taskSection = task ? `
-## Task
-
-${task}
-` : "";
-  const promptSection = prompt ? `
-## User Prompt
-
-${prompt}
-` : "";
-  return `## Context${taskSection}${promptSection}
-
-The following command failed with exit code ${exitCode}:
-\`${command}\`
-
-<stdout>
-${stdout || "(empty)"}
-</stdout>
-
-<stderr>
-${stderr || "(empty)"}
-</stderr>
-`;
-}
-
-// src/workflows/prompts/plan.ts
-import { z } from "zod";
-function getPlanPrompt(task, planContent) {
-  const planSection = planContent ? `
-The content of an existing plan file:
-<plan_file>
-${planContent}
-</plan_file>
-` : "";
-  return `# Task Input
-
-The user has provided a task:
-<task>
-${task}
-</task>
-${planSection}`;
-}
-function getPlannerSystemPrompt(loadRules) {
-  return `Role: Expert software architect and planner.
-Goal: Analyze user requests and create detailed, actionable implementation plans for software development tasks.
-
-You are an expert software architect and planner with deep experience in breaking down complex requirements into actionable implementation plans.
-
-${MEMORY_USAGE_SECTION}
-
-${TOOL_USAGE_INSTRUCTION}
-
-${AGENTS_INSTRUCTION(loadRules)}
-
-## Your Role
-
-As a planner, your expertise lies in:
-- Analyzing requirements to understand the core objective and technical implications
-- Exploring codebases to identify patterns, conventions, and integration points
-- Breaking down complex tasks into clear, logical sequences of steps
-- Anticipating dependencies, edge cases, and potential challenges
-- Creating plans that can be executed autonomously by an AI coding agent
-- Providing technical specificity required for autonomous implementation
-
-## Planning Philosophy
-
-Effective planning requires understanding before action:
-
-1. **Explore First, Plan Second**
-   - Never plan in a vacuum. Use available tools to understand the existing codebase
-   - Identify similar implementations, patterns, and conventions already in use
-   - Understand the project structure, naming conventions, and architectural patterns
-   - Look at tests to understand expected behavior and testing approaches
-
-2. **Context is Critical**
-   - The best plans are informed by the actual state of the codebase
-   - File system exploration (\`listFiles\`, \`searchFiles\`) reveals structure and patterns
-   - Reading existing files (\`readFile\`) shows coding style and conventions
-   - Understanding context prevents suggesting solutions that don't fit the project
-
-3. **Specificity Over Generality**
-   - Vague plans lead to implementation confusion and prevent autonomous execution
-   - Instead of "implement the feature," specify which files to modify, what functions to add, and what logic to implement
-   - Name specific components, modules, or files when possible
-   - Describe what needs to change and why
-   - Examples:
-     * \u274C Vague: "Implement the feature"
-     * \u2705 Specific: "Create \`src/components/LoginForm.tsx\` with a React component that includes email and password fields, using the existing \`useAuth\` hook from \`src/hooks/useAuth.ts\`"
-     * \u274C Vague: "Add error handling"
-     * \u2705 Specific: "In \`src/api/client.ts\`, wrap the fetch call in a try-catch block and throw custom errors using the \`ApiError\` class from \`src/errors.ts\`"
-
-4. **Clarity for AI Coding Agents**
-   - Plans will be executed autonomously by an AI coding agent without human intervention
-   - Break complex tasks into smaller, logical units that can be completed independently
-   - Use clear structure (numbered lists, narrative text, or combined formats) to organize steps
-   - Include exact file paths, function names, and implementation patterns
-
-## Planning for AI Implementation
-
-Plans will be executed by an AI coding agent that operates autonomously with the following capabilities:
-
-**Planning Requirements:**
-Plans should include specific technical details to enable autonomous implementation:
-- **Function/class names**: Name specific functions, classes, or components to implement
-- **Implementation patterns**: Reference existing patterns or provide clear guidance on approach
-- **Import statements**: Specify required dependencies and where to import them from
-- **Technical constraints**: Note any architectural decisions, performance requirements, or compatibility concerns
-
-**What Makes a Good AI-Actionable Plan:**
-- Each step can be completed using the available tools
-- File paths and code structures are explicitly named
-- Dependencies between steps are clear
-- Implementation approach follows existing codebase patterns
-- Technical requirements are specific, not general
-
-## Your Approach
-
-When given a planning task:
-
-1. **Understand the Goal**: Analyze the request thoroughly to grasp the primary objective and any constraints
-2. **Gather Context**: Explore the codebase using available tools to understand existing patterns and structure
-3. **Identify Patterns**: Look for similar implementations that can guide the approach
-4. **Break Down the Work**: Decompose the solution into logical, sequential steps
-5. **Be Specific**: Provide concrete details about files, functions, and implementations
-6. **Seek Clarity**: If requirements are ambiguous or critical information is missing, ask for clarification
-
-## Tool Usage Strategy
-
-Use exploration tools strategically:
-- \`listFiles\`: Understand project structure and locate relevant directories
-- \`searchFiles\`: Find existing patterns, similar implementations, or specific code
-- \`readFile\`: Examine existing code to understand style, patterns, and conventions
-- \`fetchUrl\`: Access external documentation or resources when needed
-- \`askFollowupQuestion\`: Request clarification when requirements are unclear or ambiguous
-
-The goal is to create well-informed plans based on actual codebase understanding, not assumptions.
-
-## Plan Format Guidelines
-
-When generating your plan, follow these formatting guidelines:
-
-1. Number major sections to provide clear structure:
-   a. Use numbers (1., 2., 3., etc.) for top-level sections
-   b. Use nested numbering (1.1, 1.2) or letters (a., b., c.) for sub-sections
-   c. This makes sections easy to reference and understand
-   d. Provides clear hierarchy and organization
-
-   Example section numbering:
-   1. Project Setup
-      1.1 Initialize repository
-      1.2 Configure dependencies
-   2. Implementation
-      2.1 Core features
-      2.2 Tests
-
-2. Use numbered lists when the order of steps matters:
-   a. Sequential steps where one depends on the previous
-   b. Steps that must be performed in a specific order
-   c. Processes with clear progression
-   d. When steps need to be referenced by number
-
-   Example numbered list format:
-   1. First step that must be completed first
-   2. Second step that depends on the first
-   3. Third step that follows from the second
-
-3. Use narrative or structured text format when the plan involves:
-   a. High-level strategies or conceptual approaches
-   b. Explanations or background information
-   c. Decision-making guidance
-   d. Context that doesn't translate well to discrete steps
-
-4. Combine formats when appropriate:
-   a. Use numbered sections for overall structure
-   b. Use narrative text for context and explanation
-   c. Use numbered lists for sequential steps
-
-   Example combined format:
-   1. Phase 1: Setup
-      First, we need to configure the environment...
-      1. Install dependencies
-      2. Configure settings
-      3. Verify installation
-
-   2. Phase 2: Implementation
-      The implementation should focus on...
-      1. Implement feature A
-      2. Implement feature B
-      3. Write tests
-
-5. Include implementation-ready details for AI agents:
-    a. Provide specific technical details the coding agent needs (file paths, function signatures, etc.)
-    b. Avoid steps that require human intervention or manual processes
-    c. Each step should be implementable using the AI agent's available tools
-    d. Reference existing code patterns and conventions from the codebase
-
-**Note**: Plans should use flexible formats such as numbered lists or narrative text. Checklist formats (markdown checkboxes) are NOT required and should only be used when specifically appropriate for tracking independent action items.
-
-## Decision Logic
-
-1. Analyze the task and the existing plan (if any).
-2. If the requirements are clear and you can generate or update the plan:
-   a. Provide the plan in the "plan" field
-   b. Apply appropriate formatting based on guidelines above
-   c. Include relevant file paths in the "files" array if applicable
-3. If the requirements are not clear:
-   a. Ask a clarifying question in the "question" field
-4. If the task is already implemented or no action is needed:
-   a. Do not generate a plan
-   b. Provide a concise reason in the "reason" field
-
-## IMPORTANT NOTE
-
-You MUST NOT attempt to make any modifications to the codebase. You DO NOT have access to any tools with write access.
-
-## Response Format
-
-${createJsonResponseInstruction({
-    plan: "The generated or updated plan.",
-    question: {
-      question: "The clarifying question to ask the user.",
-      defaultAnswer: "The default answer to provide if the user does not provide an answer."
-    },
-    reason: "If no plan is needed, provide a reason here.",
-    files: ["path/to/file1.ts", "path/to/file2.ts"]
-  })}
-`;
-}
-var PLANNER_SYSTEM_PROMPT = getPlannerSystemPrompt();
-var PlanSchema = z.object({
-  plan: z.string().nullish(),
-  question: z.object({
-    question: z.string(),
-    defaultAnswer: z.string().nullish()
-  }).nullish(),
-  reason: z.string().nullish(),
-  files: z.array(z.string()).nullish()
-});
-
-// src/workflows/prompts/review.ts
-var CODE_REVIEW_SYSTEM_PROMPT = `Role: Senior software engineer.
-Goal: Review code changes and provide comprehensive, actionable feedback on issues found.
-
-CRITICAL: You have VERY LIMITED tools. ONLY use: gitDiff, readFile, readBinaryFile, searchFiles, listFiles.
-DO NOT use executeCommand - it does NOT exist.
-DO NOT inspect node_modules or any dependency directories.
-
-${TOOL_USAGE_INSTRUCTION}
-
-## Review Process
-
-1.  **Identify Reviewable Files**: Use the \`<file_status>\` list to determine which files have been modified.
-2.  **Select Files for Diff**: From the modified files, select only the reviewable source and configuration files.
-    -   **Include**: Source code, config files, and template files.
-    -   **Exclude**: Lockfiles, build artifacts, test snapshots, binary/media files, data and fixtures and other generated files.
-3.  **Inspect Changes**:
-    -   The \`gitDiff\` tool is ALWAYS available for reviewing changes.
-    -   When reviewing pull requests or commit ranges: Use \`gitDiff\` with the file parameter to see exact changes.
-    -   When reviewing local changes: Use \`gitDiff\` with staged: true for staged changes, or without parameters for unstaged changes.
-    -   When reviewing a specific commit: Use \`gitDiff\` with the file parameter to see what changed in that commit.
-4.  **Analyze and Review**: Analyze the code for issues. When using \`gitDiff\`, focus only on the modified lines (additions/deletions). Provide specific, actionable feedback with accurate line numbers.
-
-## Critical Rules
-
--   **Focus on Changes**: When using \`gitDiff\`, ONLY review the actual changes shown in the diff. Do not comment on existing, unmodified code.
--   **Focus Scope**: Do not comment on overall project structure or architecture unless directly impacted by the changes in the diff.
--   **No Feature Requests**: Do not comment on missing features or functionality that are not part of this diff.
--   **One File at a Time**: Review files individually using \`gitDiff\` with the specific file path.
--   **No Empty Diffs**: MUST NOT call \`gitDiff\` with an empty or omitted file parameter. Always specify a file path.
--   **Accurate Line Numbers**: When using \`gitDiff\`, use the line numbers from the diff annotations (\`[Line N]\` for additions, \`[Line N removed]\` for deletions).
--   **No Praise**: Provide only reviews for actual issues found. Do not include praise or positive feedback.
--   **Clear Reasoning**: For each issue, provide clear reasoning explaining why it's a problem and what the impact could be.
--   **Specific Advice**: Avoid generic advice. Provide concrete, actionable suggestions specific to the code being reviewed.
--   **Assumptions**: Assume all changes have passed linter, type-checking, and unit tests. Do not check for compile errors.
--   **NO Command Execution**: DO NOT attempt to use \`executeCommand\` or any shell commands. You only have access to: \`gitDiff\`, \`readFile\`, \`readBinaryFile\`, \`searchFiles\`, and \`listFiles\`.
--   **No Dependency Inspection**: DO NOT inspect files in \`node_modules\`, \`vendor\`, or any dependency directories. Review only the project's own source code.
-
-You may receive the following context:
--   \`<pr_title>\` and \`<pr_description>\`: PR context
--   \`<commit_messages>\`: Commits in the change
--   \`<user_context>\`: Specific review focus from the user
--   \`<file_status>\`: List of modified files with their status
--   \`<review_instructions>\`: Specific instructions for this review
--   \`<target_commit>\`: The specific commit being reviewed (when reviewing past commits)
-
-## Output Format
-
-${createJsonResponseInstruction({
-  overview: "Summary of issues found, 'No issues found', or 'No reviewable changes' if all files were excluded.",
-  specificReviews: [
-    {
-      file: "path/to/file.ts",
-      lines: "42 or 15-20",
-      review: "Specific issue description and actionable fix."
-    }
-  ]
-})}
-
-### Examples
-
-**Example 1: Issues found**
-\`\`\`json
-{
-  "overview": "Found 2 security and 1 logic issue in the authentication changes.",
-  "specificReviews": [
-    {
-      "file": "src/auth/login.ts",
-      "lines": "23",
-      "review": "Password is logged in plaintext. Remove the console.log statement or hash the password before logging."
-    },
-    {
-      "file": "src/auth/login.ts",
-      "lines": "45-48",
-      "review": "Missing input validation for email field. Add email format validation before processing the login request."
-    },
-    {
-      "file": "src/utils/token.ts",
-      "lines": "12",
-      "review": "Token expiration is set to 365 days which is too long for security. Reduce to 24 hours or use refresh tokens."
-    }
-  ]
-}
-\`\`\`
-
-**Example 2: No issues**
-\`\`\`json
-{
-  "overview": "No issues found.",
-  "specificReviews": []
-}
-\`\`\`
-
-**Example 3: No reviewable changes**
-\`\`\`json
-{
-  "overview": "No reviewable changes. All modified files are lockfiles or generated artifacts.",
-  "specificReviews": []
-}
-\`\`\`
-`;
-function formatContext(tag, value) {
-  if (!value) {
-    return void 0;
-  }
-  return `<${tag}>
-${value}
-</${tag}>`;
-}
-function getReviewInstructions(params) {
-  if (params.targetCommit) {
-    return `Review the changes in commit '${params.targetCommit}'. Use the gitDiff tool with the file parameter to inspect what changed in each file. Focus your review on the actual changes shown in the diff.`;
-  }
-  if (params.commitRange) {
-    return `Review the pull request or commit range '${params.commitRange}'. Use the gitDiff tool with the file parameter to inspect the actual code changes.`;
-  }
-  if (params.staged) {
-    return "Review the staged changes. Use the gitDiff tool with the file parameter and staged: true to inspect the actual code changes.";
-  }
-  return "Review the unstaged changes. Use the gitDiff tool with the file parameter to inspect the actual code changes.";
-}
-function formatReviewToolInput(params) {
-  const fileList = params.changedFiles && params.changedFiles.length > 0 ? params.changedFiles.map((file) => {
-    let statString = "";
-    if (file.insertions !== void 0 || file.deletions !== void 0) {
-      const ins = file.insertions ?? 0;
-      const del = file.deletions ?? 0;
-      statString = ` (+${ins}/-${del})`;
-    }
-    return `${file.status}: ${file.path}${statString}`;
-  }).join("\n") : void 0;
-  const parts = [
-    formatContext("pr_title", params.pullRequestTitle),
-    formatContext("pr_description", params.pullRequestDescription),
-    formatContext("commit_messages", params.commitMessages),
-    formatContext("target_commit", params.targetCommit),
-    formatContext("user_context", params.context),
-    formatContext("file_status", fileList),
-    formatContext("review_instructions", getReviewInstructions(params))
-  ];
-  return parts.filter(Boolean).join("\n");
-}
-
-// src/workflows/prompts/init.ts
-var INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT = `
-Role: Analyzer agent
-Goal: Produce a valid polkacodes YAML configuration for the project.
-
-${TOOL_USAGE_INSTRUCTION}
-
-Workflow
-1. Scan project files to identify the project's characteristics. Start using the "readFile" tool to understand the project's dependencies, scripts, and basic configuration.
-   - Package/build tool (npm, bun, pnpm, etc.)
-   - Test framework and patterns (snapshot tests, coverage, etc.)
-   - Formatter / linter and their rules
-   - Folder structure and naming conventions.
-   - CI / development workflows (e.g., GitHub Actions in .github/workflows).
-
-2. Build a YAML config with three root keys:
-
-\`\`\`yaml
-scripts:          # derive from package.json and CI workflows. Only include scripts that are relevant for development.
-  format:        # code formatter
-    command: "<formatter cmd>"
-    description: "Format code"
-  check:         # linter / type checker
-    command: "<linter cmd>"
-    description: "Static checks"
-  test:          # test runner
-    command: "<test cmd>"
-    description: "Run tests"
-  # add any other meaningful project scripts like 'build', 'dev', etc.
-
-rules:            # A bullet list of key conventions, frameworks, and libraries used (e.g., "- React", "- TypeScript", "- Jest"). This helps other agents understand the project.
-
-excludeFiles:     # A list of glob patterns for files that should not be read. Only include files that might contain secrets.
-  - ".env"
-  - ".env.*"
-  - "*.pem"
-  - "*.key"
-  - ".npmrc"
-  # do NOT list build artifacts, lockfiles, or paths already in .gitignore
-\`\`\`
-
-3. Return a JSON object with the generated YAML configuration as a string in the 'yaml' property.
-
-${createJsonResponseInstruction({
-  yaml: "<yaml_string>"
-})}
-`;
-
-// src/workflows/prompts/meta.ts
-var META_SYSTEM_PROMPT = `Role: Meta-agent.
-Goal: Decide which workflow ('code' or 'task') to use for a given task.
-
-You are a meta-agent that decides which workflow to use for a given task.
-Based on the user's task, decide whether to use the 'code' or 'task' workflow.
-
-- Use the 'code' workflow for tasks that are well-defined and can be implemented directly without a separate planning phase.
-- Use the 'task' workflow for simple, single-action tasks like answering a question or running a command.
-
-The user's task is provided in the <task> tag.
-
-${createJsonResponseInstruction({
-  workflow: "<workflow_name>"
-  // 'code' or 'task'
-})}
-`;
-
-// src/workflows/prompts/pr.ts
-var GET_PR_DETAILS_SYSTEM_PROMPT = `Role: Expert developer.
-Goal: Generate a pull request title and description based on the branch name, commits, and diff.
-
-${TOOL_USAGE_INSTRUCTION}
-
-You are an expert at creating pull requests.
-Based on the provided branch name, commit messages, and diff, generate a title and description for the pull request.
-
-${createJsonResponseInstruction({
-  title: "feat: add new feature",
-  description: "This pull request adds a new feature that does...\\n\\n### Changes\\n- ..."
-})}
-`;
-
-// src/workflows/workflow.utils.ts
-import { execSync } from "child_process";
-import { promises as fs } from "fs";
-import path from "path";
-import { listFiles, resolveRules } from "@polka-codes/cli-shared";
-import { z as z2 } from "zod";
-
-// src/getModel.ts
-import { appendFileSync } from "fs";
-import { inspect } from "util";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createDeepSeek } from "@ai-sdk/deepseek";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createVertex } from "@ai-sdk/google-vertex";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-
-// src/env.ts
-function getEnv(override) {
-  return {
-    POLKA_API_PROVIDER: process.env.POLKA_API_PROVIDER,
-    POLKA_MODEL: process.env.POLKA_MODEL,
-    POLKA_API_KEY: process.env.POLKA_API_KEY,
-    POLKA_BUDGET: process.env.POLKA_BUDGET,
-    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
-    DEEPSEEK_API_KEY: process.env.DEEPSEEK_API_KEY,
-    OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
-    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
-    GOOGLE_API_KEY: process.env.GOOGLE_API_KEY,
-    TRACING_FILE: process.env.TRACING_FILE,
-    ...override
-  };
-}
-
-// src/getModel.ts
-function headersToObject(headers) {
-  if (!headers) {
-    return void 0;
-  }
-  if (headers instanceof Headers) {
-    return Object.fromEntries(headers.entries());
-  }
-  if (Array.isArray(headers)) {
-    return Object.fromEntries(headers);
-  }
-  return headers;
-}
-function redactHeaders(headers) {
-  if (!headers) {
-    return void 0;
-  }
-  const redactedHeaders = {};
-  const sensitiveKeywords = ["authorization", "cookie", "key", "token"];
-  for (const [key, value] of Object.entries(headers)) {
-    if (sensitiveKeywords.some((keyword) => key.toLowerCase().includes(keyword))) {
-      redactedHeaders[key] = "REDACTED";
-    } else {
-      redactedHeaders[key] = value;
-    }
-  }
-  return redactedHeaders;
-}
-var AiProvider = /* @__PURE__ */ ((AiProvider2) => {
-  AiProvider2["Anthropic"] = "anthropic";
-  AiProvider2["DeepSeek"] = "deepseek";
-  AiProvider2["OpenRouter"] = "openrouter";
-  AiProvider2["OpenAI"] = "openai";
-  AiProvider2["OpenAICompatible"] = "openai-compatible";
-  AiProvider2["GoogleVertex"] = "google-vertex";
-  AiProvider2["Google"] = "google";
-  return AiProvider2;
-})(AiProvider || {});
-var getModel = (config, debugLogging = false) => {
-  const { TRACING_FILE } = getEnv();
-  const fetchOverride = debugLogging || TRACING_FILE ? (async (url, options) => {
-    const requestBody = options?.body ? JSON.parse(options.body) : void 0;
-    if (debugLogging) {
-      console.error("-> Request URL:", url);
-      console.error("-> Request Headers:", options?.headers);
-      console.error("-> Request Body:");
-      console.error(inspect(requestBody, { depth: null, colors: process.stderr.isTTY }));
-    }
-    if (TRACING_FILE) {
-      appendFileSync(
-        TRACING_FILE,
-        `${JSON.stringify(
-          {
-            type: "request",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            url,
-            headers: redactHeaders(headersToObject(options?.headers)),
-            body: requestBody
-          },
-          null,
-          2
-        )}
-`
-      );
-    }
-    const res = await fetch(url, options);
-    if (debugLogging) {
-      console.error("<- Response Status:", res.status);
-    }
-    const contentType = res.headers.get("content-type") || "";
-    if (contentType.includes("text/event-stream") && res.body) {
-      const [branch, clientStream] = res.body.tee();
-      (async () => {
-        const reader = branch.getReader();
-        const decoder = new TextDecoder();
-        try {
-          let done = false;
-          while (!done) {
-            const { value, done: d } = await reader.read();
-            done = d;
-            if (value) {
-              const text = decoder.decode(value);
-              if (debugLogging) {
-                console.error("<- Stream chunk:", text.replace(/\n/g, "\\n"));
-              }
-              if (TRACING_FILE) {
-                for (const line of text.split("\n")) {
-                  if (line.startsWith("data:")) {
-                    const content = line.slice("data:".length).trim();
-                    if (content) {
-                      try {
-                        const json = JSON.parse(content);
-                        appendFileSync(
-                          TRACING_FILE,
-                          `${JSON.stringify(
-                            {
-                              type: "response-chunk",
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                              chunk: json
-                            },
-                            null,
-                            2
-                          )}
-`
-                        );
-                      } catch (_e) {
-                        appendFileSync(
-                          TRACING_FILE,
-                          `${JSON.stringify(
-                            {
-                              type: "response-chunk",
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                              chunk: content
-                            },
-                            null,
-                            2
-                          )}
-`
-                        );
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      })().catch((error) => {
-        if (debugLogging) {
-          console.error("Stream reading error:", error);
-        }
-      });
-      return new Response(clientStream, {
-        headers: res.headers,
-        status: res.status
-      });
-    }
-    const full = await res.text();
-    let responseBody;
-    try {
-      responseBody = JSON.parse(full);
-    } catch (_error) {
-      responseBody = full;
-    }
-    if (debugLogging) {
-      console.error("<- Response Body:");
-      console.error(inspect(responseBody, { depth: null, colors: process.stderr.isTTY }));
-    }
-    if (TRACING_FILE) {
-      appendFileSync(
-        TRACING_FILE,
-        `${JSON.stringify(
-          {
-            type: "response",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            status: res.status,
-            headers: redactHeaders(Object.fromEntries(res.headers.entries())),
-            body: responseBody
-          },
-          null,
-          2
-        )}
-`
-      );
-    }
-    return new Response(full, {
-      headers: res.headers,
-      status: res.status
-    });
-  }) : void 0;
-  switch (config.provider) {
-    case "anthropic" /* Anthropic */: {
-      const anthropic = createAnthropic({
-        apiKey: config.apiKey,
-        baseURL: config.baseUrl,
-        fetch: fetchOverride
-      });
-      return anthropic(config.model);
-    }
-    case "deepseek" /* DeepSeek */: {
-      const deepseek = createDeepSeek({
-        apiKey: config.apiKey,
-        baseURL: config.baseUrl,
-        fetch: fetchOverride
-      });
-      return deepseek(config.model);
-    }
-    case "openrouter" /* OpenRouter */: {
-      const openrouter = createOpenRouter({
-        apiKey: config.apiKey,
-        baseURL: config.baseUrl,
-        fetch: fetchOverride,
-        headers: {
-          "HTTP-Referer": "https://polka.codes",
-          "X-Title": "Polka Codes"
-        }
-      });
-      return openrouter.chat(config.model, {
-        usage: { include: true }
-      });
-    }
-    case "openai" /* OpenAI */: {
-      const openai = createOpenAI({
-        apiKey: config.apiKey,
-        baseURL: config.baseUrl,
-        fetch: fetchOverride
-      });
-      return openai(config.model);
-    }
-    case "openai-compatible" /* OpenAICompatible */: {
-      if (!config.baseUrl) {
-        throw new Error("OpenAI-compatible providers require a baseUrl");
-      }
-      const openaiCompatible = createOpenAICompatible({
-        apiKey: config.apiKey,
-        baseURL: config.baseUrl,
-        name: config.name || "OpenAI Compatible",
-        fetch: fetchOverride
-      });
-      return openaiCompatible(config.model);
-    }
-    case "google-vertex" /* GoogleVertex */: {
-      const vertex = createVertex({
-        fetch: fetchOverride,
-        location: config.location,
-        project: config.project,
-        googleAuthOptions: {
-          keyFile: config.keyFile
-        }
-      });
-      return vertex(config.model);
-    }
-    case "google" /* Google */: {
-      const google = createGoogleGenerativeAI({
-        fetch: fetchOverride,
-        apiKey: config.apiKey
-      });
-      return google(config.model);
-    }
-  }
-};
-
-// src/ApiProviderConfig.ts
-var defaultModels = {
-  ["anthropic" /* Anthropic */]: "claude-sonnet-4-20250514",
-  ["deepseek" /* DeepSeek */]: "deepseek-chat",
-  ["openrouter" /* OpenRouter */]: "google/gemini-2.5-pro",
-  ["openai" /* OpenAI */]: "gpt-5-2025-08-07",
-  ["openai-compatible" /* OpenAICompatible */]: "gpt-4o",
-  ["google-vertex" /* GoogleVertex */]: "gemini-2.5-pro",
-  ["google" /* Google */]: "gemini-2.5-pro"
-};
-var ApiProviderConfig = class {
-  defaultProvider;
-  providers;
-  commands;
-  defaultParameters;
-  constructor(config) {
-    this.defaultProvider = config.defaultProvider;
-    this.defaultParameters = config.defaultParameters ?? {};
-    this.providers = config.providers ?? {};
-    this.commands = config.commands;
-  }
-  getConfigForCommand(command) {
-    const commandConfig = this.commands?.[command];
-    const defaultConfig = this.commands?.default;
-    const mergedConfig = { ...defaultConfig, ...commandConfig };
-    return this.resolveModelConfig(mergedConfig);
-  }
-  resolveModelConfig(config) {
-    const { provider, model, parameters, budget, rules } = config;
-    const finalProvider = provider ?? this.defaultProvider;
-    if (!finalProvider) {
-      return void 0;
-    }
-    const { apiKey, defaultModel, defaultParameters, location, project, keyFile, baseUrl, name } = this.providers[finalProvider] ?? {};
-    const finalModel = model ?? defaultModel ?? defaultModels[finalProvider];
-    const finalParameters = {
-      ...this.defaultParameters,
-      ...defaultParameters ?? {},
-      ...parameters ?? {}
-    };
-    return {
-      provider: finalProvider,
-      model: finalModel,
-      apiKey,
-      location,
-      project,
-      keyFile,
-      baseUrl,
-      name,
-      parameters: finalParameters,
-      budget,
-      rules
-    };
-  }
-};
-
-// src/workflows/workflow.utils.ts
-function parseGitDiffNameStatus(diffOutput) {
-  const lines = diffOutput.split("\n").filter((line) => line.trim());
-  return lines.map((line) => {
-    const [status, ...pathParts] = line.split("	");
-    const path2 = pathParts.join("	");
-    let statusDescription;
-    switch (status[0]) {
-      case "A":
-        statusDescription = "Added";
-        break;
-      case "M":
-        statusDescription = "Modified";
-        break;
-      case "D":
-        statusDescription = "Deleted";
-        break;
-      case "R":
-        statusDescription = "Renamed";
-        break;
-      case "C":
-        statusDescription = "Copied";
-        break;
-      case "T":
-        statusDescription = "Type changed";
-        break;
-      default:
-        statusDescription = "Unknown";
-    }
-    return { path: path2, status: statusDescription };
-  });
-}
-function printChangedFiles(logger, changedFiles) {
-  if (changedFiles.length === 0) {
-    return;
-  }
-  logger.info("Changed Files:");
-  for (const file of changedFiles) {
-    let statString = "";
-    if (file.insertions !== void 0 || file.deletions !== void 0) {
-      const ins = file.insertions ?? 0;
-      const del = file.deletions ?? 0;
-      statString = ` (+${ins}/-${del})`;
-    }
-    logger.info(`- ${file.status}: ${file.path}${statString}`);
-  }
-}
-function parseGitDiffNumStat(output) {
-  const stats = {};
-  const lines = output.split("\n").filter((line) => line.trim());
-  for (const line of lines) {
-    const parts = line.split("	");
-    if (parts.length >= 3) {
-      const insertions = parts[0] === "-" ? 0 : Number.parseInt(parts[0], 10);
-      const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1], 10);
-      const path2 = unquotePath(parts.slice(2).join("	"));
-      stats[path2] = { insertions, deletions };
-    }
-  }
-  return stats;
-}
-var unquotePath = (path2) => {
-  if (path2.startsWith('"') && path2.endsWith('"')) {
-    try {
-      return JSON.parse(path2);
-    } catch {
-      return path2;
-    }
-  }
-  return path2;
-};
-function parseGitStatus(statusOutput) {
-  const statusLines = statusOutput.split("\n").filter((line) => line);
-  const files = [];
-  for (const line of statusLines) {
-    const indexStatus = line[0];
-    const workingTreeStatus = line[1];
-    const path2 = line.length > 3 ? unquotePath(line.slice(3)) : line;
-    const statuses = [];
-    if (indexStatus !== " " && indexStatus !== "?") {
-      switch (indexStatus) {
-        case "A":
-          statuses.push("Added (staged)");
-          break;
-        case "M":
-          statuses.push("Modified (staged)");
-          break;
-        case "D":
-          statuses.push("Deleted (staged)");
-          break;
-        case "R":
-          statuses.push("Renamed (staged)");
-          break;
-        case "C":
-          statuses.push("Copied (staged)");
-          break;
-        default:
-          statuses.push("Changed (staged)");
-      }
-    }
-    if (workingTreeStatus !== " ") {
-      switch (workingTreeStatus) {
-        case "M":
-          statuses.push("Modified (unstaged)");
-          break;
-        case "D":
-          statuses.push("Deleted (unstaged)");
-          break;
-        case "?":
-          statuses.push("Untracked");
-          break;
-        default:
-          statuses.push("Changed (unstaged)");
-      }
-    }
-    if (statuses.length > 0) {
-      files.push({ path: path2, status: statuses.join(", ") });
-    }
-  }
-  return files;
-}
-function getLocalChanges() {
-  const statusOutput = execSync("git status --porcelain=v1", {
-    encoding: "utf-8"
-  });
-  const allFiles = parseGitStatus(statusOutput);
-  let stagedStats = {};
-  try {
-    const stagedDiffOutput = execSync("git diff --staged --numstat --no-color", { encoding: "utf-8" });
-    stagedStats = parseGitDiffNumStat(stagedDiffOutput);
-  } catch {
-  }
-  let unstagedStats = {};
-  try {
-    const unstagedDiffOutput = execSync("git diff --numstat --no-color", { encoding: "utf-8" });
-    unstagedStats = parseGitDiffNumStat(unstagedDiffOutput);
-  } catch {
-  }
-  const stagedFiles = [];
-  const unstagedFiles = [];
-  for (const file of allFiles) {
-    let totalInsertions = 0;
-    let totalDeletions = 0;
-    if (file.status.includes("(staged)")) {
-      const stats = stagedStats[file.path];
-      const stagedFile = { ...file };
-      if (stats) {
-        stagedFile.insertions = stats.insertions;
-        stagedFile.deletions = stats.deletions;
-        totalInsertions += stats.insertions;
-        totalDeletions += stats.deletions;
-      }
-      stagedFiles.push(stagedFile);
-    }
-    if (file.status.includes("(unstaged)")) {
-      const stats = unstagedStats[file.path];
-      const unstagedFile = { ...file };
-      if (stats) {
-        unstagedFile.insertions = stats.insertions;
-        unstagedFile.deletions = stats.deletions;
-        totalInsertions += stats.insertions;
-        totalDeletions += stats.deletions;
-      }
-      unstagedFiles.push(unstagedFile);
-    } else if (file.status.includes("Untracked")) {
-      unstagedFiles.push(file);
-    }
-    if (totalInsertions > 0 || totalDeletions > 0) {
-      file.insertions = totalInsertions;
-      file.deletions = totalDeletions;
-    }
-  }
-  return { stagedFiles, unstagedFiles, allFiles };
-}
-var specificReviewSchema = z2.object({
-  file: z2.string(),
-  lines: z2.string(),
-  review: z2.string()
-});
-var reviewOutputSchema = z2.object({
-  overview: z2.string(),
-  specificReviews: z2.array(specificReviewSchema).optional()
-});
-function formatReviewForConsole(output) {
-  let formatted = `### Overview
-
-${output.overview}`;
-  if (output.specificReviews && output.specificReviews.length > 0) {
-    formatted += "\n\n### File-specific feedback\n";
-    for (const item of output.specificReviews) {
-      formatted += `
-- ${item.file}#${item.lines}
-
-${item.review}
-`;
-    }
-  }
-  return formatted;
-}
-var checkGhInstalled = async (executeCommand) => {
-  const result = await executeCommand({ command: "gh", args: ["--version"] });
-  if (result.exitCode !== 0) {
-    throw new Error("GitHub CLI (gh) is not installed. Please install it from https://cli.github.com/");
-  }
-};
-var getDefaultBranch = async (executeCommand) => {
-  const branchResult = await executeCommand({
-    command: "gh",
-    args: ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"]
-  });
-  if (branchResult.exitCode === 0) {
-    const branch = branchResult.stdout.trim();
-    if (branch) {
-      return branch;
-    }
-  }
-  const defaultBranches = ["master", "main", "develop"];
-  for (const branch of defaultBranches) {
-    const result = await executeCommand({
-      command: "git",
-      args: ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]
-    });
-    if (result.exitCode === 0) {
-      return branch;
-    }
-  }
-  const remoteResult = await executeCommand({ command: "git", args: ["remote", "show", "origin"] });
-  if (remoteResult.exitCode === 0) {
-    const match = remoteResult.stdout.match(/HEAD branch: (.*)/);
-    if (match?.[1]) {
-      return match[1];
-    }
-  }
-  return void 0;
-};
-async function getDefaultContext(config, commandName) {
-  const cwd = process.cwd();
-  const [files, truncated] = await listFiles(cwd, true, 2e3, cwd, config?.excludeFiles ?? []);
-  const fileList = files.join("\n");
-  const now = /* @__PURE__ */ new Date();
-  const formattedDate = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}-${String(now.getUTCDate()).padStart(2, "0")}`;
-  const contextParts = [
-    `<file_list truncated="${truncated}">
-${fileList}
-</file_list>`,
-    `<now_date>${formattedDate}</now_date>`
-  ];
-  const loadRules = config?.loadRules;
-  const defaultLoadRules = {
-    "AGENTS.md": true,
-    "CLAUDE.md": true
-  };
-  const mergedRules = { ...defaultLoadRules, ...loadRules };
-  for (const [fileName, shouldLoad] of Object.entries(mergedRules)) {
-    if (shouldLoad) {
-      try {
-        const content = await fs.readFile(path.join(cwd, fileName), "utf-8");
-        const tagName = fileName.replace(/\./g, "_");
-        contextParts.push(`<${tagName}_instructions>
-${content}
-</${tagName}_instructions>`);
-      } catch {
-      }
-    }
-  }
-  let rules = await resolveRules(config?.rules);
-  if (commandName && config) {
-    const apiConfig = new ApiProviderConfig(config);
-    const commandConfig = apiConfig.getConfigForCommand(commandName);
-    if (commandConfig?.rules) {
-      const commandRules = await resolveRules(commandConfig.rules);
-      if (commandRules) {
-        rules = rules ? `${rules}
-
-${commandRules}` : commandRules;
-      }
-    }
-  }
-  if (rules) {
-    contextParts.push(`<rules>
-${rules}
-</rules>`);
-  }
-  if (config?.scripts) {
-    const scripts = Object.entries(config.scripts).map(([name, script]) => {
-      if (typeof script === "string") {
-        return `${name}: ${script}`;
-      }
-      if ("command" in script) {
-        return `${name}: ${script.command}${script.description ? ` # ${script.description}` : ""}`;
-      }
-      if ("workflow" in script) {
-        return `${name}: workflow:${script.workflow}${script.description ? ` # ${script.description}` : ""}`;
-      }
-      if ("script" in script) {
-        return `${name}: script:${script.script}${script.description ? ` # ${script.description}` : ""}`;
-      }
-      return `${name}: unknown`;
-    }).join("\n");
-    if (scripts.length > 0) {
-      contextParts.push(`<scripts>
-${scripts}
-</scripts>`);
-    }
-  }
-  return { context: contextParts.join("\n"), loadRules };
-}
-
-export {
-  getCoderSystemPrompt,
-  getImplementPrompt,
-  COMMIT_MESSAGE_SYSTEM_PROMPT,
-  FIX_SYSTEM_PROMPT,
-  getFixUserPrompt,
-  INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT,
-  META_SYSTEM_PROMPT,
-  getPlanPrompt,
-  getPlannerSystemPrompt,
-  PlanSchema,
-  GET_PR_DETAILS_SYSTEM_PROMPT,
-  CODE_REVIEW_SYSTEM_PROMPT,
-  formatReviewToolInput,
-  getEnv,
-  AiProvider,
-  getModel,
-  ApiProviderConfig,
-  parseGitDiffNameStatus,
-  printChangedFiles,
-  parseGitDiffNumStat,
-  parseGitStatus,
-  getLocalChanges,
-  reviewOutputSchema,
-  formatReviewForConsole,
-  checkGhInstalled,
-  getDefaultBranch,
-  getDefaultContext
-};