@polka-codes/cli 0.10.23 → 0.10.24

package/dist/test/workflow-fixtures.js

@@ -1,120 +0,0 @@
-/**
- * Workflow Testing Fixtures
- *
- * Provides reusable fixtures for workflow testing with reduced mock usage
- * and better type safety. Addresses P0 mock overuse issues from test review plan.
- */
-import { mock } from 'bun:test';
-/**
- * Create a workflow test context with properly typed mocks
- *
- * This is a minimal fixture - only mocks what cannot be tested with real implementations.
- * Following the test review plan's guidance:
- * - Prefer real implementations over mocks
- * - Use typed mocks, not 'any'
- * - Maximum 3-5 mocks per test (enforced by this fixture's API)
- */
-export function createWorkflowTestContext() {
-    // Only mock the tools that are actually needed for workflow testing
-    const tools = {
-        executeCommand: mock(),
-        input: mock(),
-        generateText: mock(),
-        taskEvent: mock(),
-        getMemoryContext: mock().mockResolvedValue(''),
-        updateMemory: mock(),
-        printChangeFile: mock(),
-        createCommit: mock(),
-        confirm: mock(),
-        select: mock(),
-        readFile: mock(),
-        writeToFile: mock(),
-        createPullRequest: mock(),
-        invokeTool: mock(),
-    };
-    const step = mock(async (_name, arg2, arg3) => {
-        const fn = typeof arg2 === 'function' ? arg2 : arg3;
-        if (typeof fn === 'function') {
-            return fn();
-        }
-        return undefined;
-    });
-    const logger = {
-        info: mock(() => { }),
-        error: mock(() => { }),
-        warn: mock(() => { }),
-        debug: mock(() => { }),
-    };
-    const context = {
-        tools,
-        step,
-        logger,
-    };
-    return { context, tools, step, logger };
-}
-/**
- * Helper to set up successful command execution
- * @param tools - Tools object from createWorkflowTestContext
- * @param stdout - Standard output to return
- * @param stderr - Standard error to return (default: '')
- * @param exitCode - Exit code to return (default: 0)
- */
-export function mockSuccessfulCommand(tools, stdout, stderr = '', exitCode = 0) {
-    tools.executeCommand.mockResolvedValue({ exitCode, stdout, stderr });
-}
-/**
- * Helper to set up failed command execution
- * @param tools - Tools object from createWorkflowTestContext
- * @param stdout - Standard output to return (default: 'FAIL')
- * @param stderr - Standard error to return (default: 'Error')
- */
-export function mockFailedCommand(tools, stdout = 'FAIL', stderr = 'Error') {
-    tools.executeCommand.mockResolvedValue({ exitCode: 1, stdout, stderr });
-}
-/**
- * Helper to set up agent response
- * @param tools - Tools object from createWorkflowTestContext
- * @param summary - Summary text from agent
- * @param bailReason - Optional bail reason
- */
-export function mockAgentResponse(tools, summary, bailReason) {
-    const content = JSON.stringify({ summary, bailReason: bailReason ?? null });
-    tools.generateText.mockResolvedValue([
-        {
-            role: 'assistant',
-            content: `\`\`\`json\n${content}\n\`\`\``,
-        },
-    ]);
-}
-/**
- * Helper to set up multiple command attempts (e.g., for retry logic)
- * @param tools - Tools object from createWorkflowTestContext
- * @param attempts - Array of exit codes for each attempt
- */
-export function mockCommandAttempts(tools, attempts) {
-    for (const exitCode of attempts) {
-        tools.executeCommand.mockResolvedValueOnce({
-            exitCode,
-            stdout: exitCode === 0 ? 'PASS' : 'FAIL',
-            stderr: exitCode === 0 ? '' : 'Error',
-        });
-    }
-}
-/**
- * Helper to verify exact number of tool calls (deprecated - use expect() directly)
- * @param tools - Tools object from createWorkflowTestContext
- * @param expectations - Object mapping tool names to expected call counts
- */
-// Note: Not used - use expect(tool).toHaveBeenCalledTimes(count) directly in tests
-/*
-export function expectToolCalls(
-  tools: WorkflowTestContext['tools'],
-  expectations: Partial<Record<keyof WorkflowTestContext['tools'], number>>,
-): void {
-  for (const [toolName, expectedCount] of Object.entries(expectations)) {
-    const tool = tools[toolName as keyof typeof tools]
-    expect(tool).toHaveBeenCalledTimes(expectedCount)
-  }
-}
-*/
-//# sourceMappingURL=workflow-fixtures.js.map

package/dist/test/workflow-fixtures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-fixtures.js","sourceRoot":"","sources":["../../src/test/workflow-fixtures.ts"],"names":[],"mappings":"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"}

package/dist/tool-implementations.js

@@ -1,521 +0,0 @@
-// generated by polka.codes
-import { spawn, spawnSync } from 'node:child_process';
-import { confirm as inquirerConfirm, select as inquirerSelect } from '@inquirer/prompts';
-import { agentWorkflow, askFollowupQuestion, computeRateLimitBackoffSeconds, listSkills as coreListSkills, loadSkill as coreLoadSkill, readSkillFile as coreReadSkillFile, executeCommand as executeCommandTool, fetchUrl, fromJsonModelMessage, listFiles as listFilesTool, readBinaryFile, readFile as readFileTool, removeFile, renameFile, replaceInFile, SOURCE_ICONS, search, searchFiles, TaskEventKind, toJsonModelMessage, writeToFile as writeToFileTool, } from '@polka-codes/core';
-import { streamText } from 'ai';
-import { createProviderErrorFromStatus, MaxRetriesExceededError, ProviderTimeoutError, QuotaExceededError, UserCancelledError, } from './errors';
-import { McpError } from './mcp/errors';
-import { createSkillContext, generateSkillsSystemPrompt } from './skillIntegration';
-import { getTodoItem as getTodoItemTool, gitDiff, listMemoryTopics as listMemoryTopicsTool, listTodoItems as listTodoItemsTool, readMemory as readMemoryTool, updateMemory as updateMemoryTool, updateTodoItem as updateTodoItemTool, } from './tools';
-import { applyCacheControl } from './utils/cacheControl';
-import { getUserInput } from './utils/userInput';
-import { getLocalChanges } from './workflows/workflow.utils';
-const allTools = [
-    askFollowupQuestion,
-    executeCommandTool,
-    fetchUrl,
-    listFilesTool,
-    readBinaryFile,
-    readFileTool,
-    readMemoryTool,
-    listMemoryTopicsTool,
-    updateMemoryTool,
-    removeFile,
-    renameFile,
-    replaceInFile,
-    search,
-    searchFiles,
-    writeToFileTool,
-    gitDiff,
-    getTodoItemTool,
-    listTodoItemsTool,
-    updateTodoItemTool,
-];
-export const toolHandlers = new Map(allTools.map((t) => [t.name, t]));
-async function createPullRequest(input, _context) {
-    spawnSync('gh', ['pr', 'create', '--title', input.title, '--body', input.description], {
-        stdio: 'inherit',
-    });
-    return { title: input.title, description: input.description };
-}
-async function createCommit(input, _context) {
-    const result = spawnSync('git', ['commit', '-m', input.message], {
-        stdio: 'inherit',
-    });
-    if (result.status !== 0) {
-        throw new Error('Commit failed');
-    }
-    return { message: input.message };
-}
-async function printChangeFile(_input, context) {
-    const { stagedFiles, unstagedFiles } = getLocalChanges();
-    if (stagedFiles.length === 0 && unstagedFiles.length === 0) {
-        context.workflowContext.logger.info('No changes to commit.');
-    }
-    else {
-        if (stagedFiles.length > 0) {
-            context.workflowContext.logger.info('Staged files:');
-            for (const file of stagedFiles) {
-                context.workflowContext.logger.info(`- ${file.status}: ${file.path}`);
-            }
-        }
-        if (unstagedFiles.length > 0) {
-            context.workflowContext.logger.info('\nUnstaged files:');
-            for (const file of unstagedFiles) {
-                context.workflowContext.logger.info(`- ${file.status}: ${file.path}`);
-            }
-        }
-    }
-    return { stagedFiles, unstagedFiles };
-}
-async function confirm(input, context) {
-    if (context.yes) {
-        return true;
-    }
-    // to allow ora to fully stop the spinner so inquirer can takeover the cli window
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    process.stderr.write('\u0007');
-    return await inquirerConfirm({ message: input.message });
-}
-async function input(input, context) {
-    if (context.yes) {
-        return input.default ?? '';
-    }
-    // to allow ora to fully stop the spinner so inquirer can takeover the cli window
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    process.stderr.write('\u0007');
-    const result = await getUserInput(input.message, {
-        default: input.default,
-    });
-    if (result === undefined) {
-        throw new UserCancelledError();
-    }
-    return result;
-}
-async function select(input, context) {
-    if (context.yes) {
-        return input.choices[0].value;
-    }
-    // to allow ora to fully stop the spinner so inquirer can takeover the cli window
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    process.stderr.write('\u0007');
-    return await inquirerSelect({ message: input.message, choices: input.choices });
-}
-async function executeCommand(input) {
-    return new Promise((resolve, reject) => {
-        // SECURITY: When shell: true, use args as separate parameters to prevent command injection
-        // If args are provided, we use them as separate spawn arguments even with shell: true
-        // This is safer than concatenating command + args into a single string
-        const child = input.shell === true
-            ? input.args && input.args.length > 0
-                ? // Use shell: true with command and args as separate parameters for safety
-                    spawn(input.command, input.args, { shell: true, stdio: 'pipe' })
-                : // No args, just the command
-                    spawn(input.command, { shell: true, stdio: 'pipe' })
-            : // shell: false or not specified - always use separate args
-                spawn(input.command, input.args, {
-                    shell: false,
-                    stdio: 'pipe',
-                });
-        let stdout = '';
-        let stderr = '';
-        let stdoutEnded = !child.stdout;
-        let stderrEnded = !child.stderr;
-        let closeEventFired = false;
-        let exitCode = null;
-        const checkAndResolve = () => {
-            if (stdoutEnded && stderrEnded && closeEventFired) {
-                resolve({ exitCode: exitCode ?? -1, stdout, stderr });
-            }
-        };
-        if (child.stdout) {
-            child.stdout.setEncoding('utf8');
-            child.stdout.on('data', (data) => {
-                if (input.pipe) {
-                    process.stdout.write(data);
-                }
-                stdout += data;
-            });
-            child.stdout.on('end', () => {
-                stdoutEnded = true;
-                checkAndResolve();
-            });
-        }
-        if (child.stderr) {
-            child.stderr.setEncoding('utf8');
-            child.stderr.on('data', (data) => {
-                if (input.pipe) {
-                    process.stderr.write(data);
-                }
-                stderr += data;
-            });
-            child.stderr.on('end', () => {
-                stderrEnded = true;
-                checkAndResolve();
-            });
-        }
-        child.on('close', (code) => {
-            exitCode = code;
-            closeEventFired = true;
-            checkAndResolve();
-        });
-        child.on('error', (err) => {
-            reject(err);
-        });
-    });
-}
-async function generateText(input, context) {
-    const { model, agentCallback } = context;
-    if (!model) {
-        throw new Error('Model not found in context');
-    }
-    // Check usage limits
-    const limitResult = context.parameters.usageMeter.isLimitExceeded();
-    if (limitResult.result) {
-        agentCallback?.({
-            kind: TaskEventKind.UsageExceeded,
-        });
-        throw new QuotaExceededError(model.provider, model.modelId, context.parameters.usageMeter.usage.cost, limitResult.maxCost);
-    }
-    const { retryCount = 5, requestTimeoutSeconds = 90 } = context.parameters;
-    // Convert messages and apply cache control
-    const messages = applyCacheControl(input.messages.map(fromJsonModelMessage), model.provider, model.modelId);
-    // Repetition detection constants
-    const REPETITION_DETECTION_WINDOW = 20;
-    const REPETITION_CHECK_HALF = 10;
-    const REPETITION_MIN_LENGTH = 20;
-    let lastError;
-    for (let i = 0; i < retryCount; i++) {
-        const abortController = new AbortController();
-        let timeout = setTimeout(() => abortController.abort(), requestTimeoutSeconds * 1000);
-        const lastOutputs = [];
-        let repetitionDetected = false;
-        const usageMeterOnFinishHandler = context.parameters.usageMeter.onFinishHandler(model);
-        try {
-            const stream = streamText({
-                model,
-                temperature: 0,
-                messages,
-                tools: input.tools,
-                async onChunk({ chunk }) {
-                    clearTimeout(timeout);
-                    timeout = setTimeout(() => abortController.abort(), requestTimeoutSeconds * 1000);
-                    switch (chunk.type) {
-                        case 'text-delta':
-                            lastOutputs.push(chunk.text);
-                            if (lastOutputs.length > REPETITION_DETECTION_WINDOW) {
-                                lastOutputs.shift();
-                            }
-                            if (lastOutputs.length === REPETITION_DETECTION_WINDOW) {
-                                const firstHalf = lastOutputs.slice(0, REPETITION_CHECK_HALF).join('');
-                                const secondHalf = lastOutputs.slice(REPETITION_CHECK_HALF).join('');
-                                if (firstHalf === secondHalf) {
-                                    if (firstHalf.length > REPETITION_MIN_LENGTH) {
-                                        repetitionDetected = true;
-                                        abortController.abort();
-                                    }
-                                }
-                            }
-                            agentCallback?.({
-                                kind: TaskEventKind.Text,
-                                newText: chunk.text,
-                            });
-                            break;
-                        case 'reasoning-delta':
-                            agentCallback?.({
-                                kind: TaskEventKind.Reasoning,
-                                newText: chunk.text,
-                            });
-                            break;
-                    }
-                },
-                onFinish(result) {
-                    usageMeterOnFinishHandler?.(result);
-                },
-                providerOptions: context.parameters.providerOptions,
-                abortSignal: abortController.signal,
-            });
-            await stream.consumeStream({
-                onError: (error) => {
-                    context.workflowContext.logger.error('Error in stream:', error);
-                    lastError = error instanceof Error ? error : new Error(String(error));
-                },
-            });
-            const resp = await stream.response;
-            return resp.messages.map(toJsonModelMessage);
-        }
-        catch (error) {
-            // Handle AbortError (timeouts and repetition)
-            if (error instanceof Error && error.name === 'AbortError') {
-                if (repetitionDetected) {
-                    context.workflowContext.logger.warn('Repetition detected, retrying...');
-                    lastError = new Error('Repetition detected in model output');
-                    continue;
-                }
-                // This is a timeout
-                context.workflowContext.logger.warn(`Request timed out after ${requestTimeoutSeconds} seconds, retrying...`);
-                lastError = new ProviderTimeoutError(model.provider, model.modelId, requestTimeoutSeconds);
-                continue;
-            }
-            // Handle HTTP errors
-            if (error && typeof error === 'object' && 'response' in error) {
-                const errorWithResponse = error;
-                const response = errorWithResponse.response;
-                const statusCode = response.status;
-                // Create appropriate error based on status code
-                const providerError = createProviderErrorFromStatus(model.provider, model.modelId, statusCode, error instanceof Error ? error : undefined);
-                // Only retry if error is retryable
-                if (providerError.retryable && (statusCode === 429 || statusCode >= 500)) {
-                    context.workflowContext.logger.warn(`${providerError.message} (attempt ${i + 1}/${retryCount})`);
-                    lastError = providerError;
-                    const backoff = computeRateLimitBackoffSeconds(i);
-                    context.workflowContext.logger.debug(`Waiting ${backoff}s before retry...`);
-                    await new Promise((resolve) => setTimeout(resolve, backoff * 1000));
-                    continue;
-                }
-                // Non-retryable HTTP error - throw immediately
-                throw providerError;
-            }
-            // Handle other errors
-            if (error instanceof Error) {
-                // Check for network errors
-                if (error.message.includes('ECONNREFUSED') || error.message.includes('ENOTFOUND') || error.message.includes('ETIMEDOUT')) {
-                    context.workflowContext.logger.warn(`Network error: ${error.message}, retrying...`);
-                    lastError = error;
-                    continue;
-                }
-                // Unknown error - save and continue to retry
-                context.workflowContext.logger.warn(`Unexpected error: ${error.message}, retrying...`);
-                lastError = error;
-                continue;
-            }
-            // Non-Error throwable
-            lastError = new Error(String(error));
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    // All retries exhausted
-    throw new MaxRetriesExceededError(model.provider, model.modelId, retryCount, lastError || new Error('Unknown error'));
-}
-async function invokeTool(input, context) {
-    const tool = toolHandlers.get(input.toolName);
-    if (!tool) {
-        return {
-            success: false,
-            message: {
-                type: 'error-text',
-                value: `Tool not found: ${input.toolName}`,
-            },
-        };
-    }
-    try {
-        const result = await tool.handler(context.toolProvider, input.input);
-        return result;
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: {
-                type: 'error-text',
-                value: error instanceof Error ? error.message : String(error),
-            },
-        };
-    }
-}
-async function taskEvent(input, context) {
-    await context.agentCallback?.(input);
-}
-async function getMemoryContext(_input, context) {
-    const provider = context.toolProvider;
-    const topics = await provider.listMemoryTopics();
-    const defaultContent = await provider.readMemory();
-    const contextParts = [];
-    if (topics?.length > 0) {
-        const topicList = topics.map((topic) => `- ${topic}`).join('\n');
-        contextParts.push(`<memory_topics>\n${topicList}\n</memory_topics>`);
-    }
-    if (defaultContent) {
-        contextParts.push(`<memory topic=":default:">\n${defaultContent}\n</memory>`);
-    }
-    return contextParts.join('\n');
-}
-async function listTodoItems(input, context) {
-    const provider = context.toolProvider;
-    return provider.listTodoItems(input.id, input.status);
-}
-async function getTodoItem(input, context) {
-    const provider = context.toolProvider;
-    return provider.getTodoItem(input.id);
-}
-async function updateTodoItem(input, context) {
-    const provider = context.toolProvider;
-    return provider.updateTodoItem(input);
-}
-async function runAgent(input, context) {
-    return await agentWorkflow(input, context.workflowContext);
-}
-/**
- * Wrapper for skill tool operations that handles context validation and error handling
- */
-async function withSkillContext(context, fn) {
-    if (!context.parameters.skillContext) {
-        return {
-            success: false,
-            message: { type: 'error-text', value: 'Skill context not initialized' },
-        };
-    }
-    try {
-        return await fn(context.parameters.skillContext);
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: {
-                type: 'error-text',
-                value: error instanceof Error ? error.message : String(error),
-            },
-        };
-    }
-}
-async function loadSkill(input, context) {
-    return withSkillContext(context, async (skillContext) => {
-        const result = await coreLoadSkill(input, skillContext);
-        if (!result.success || !result.skill) {
-            return {
-                success: false,
-                message: { type: 'error-text', value: result.error ?? 'Failed to load skill' },
-            };
-        }
-        return {
-            success: true,
-            message: {
-                type: 'text',
-                value: `Loaded skill '${result.skill.name}':\n\n${result.skill.content}\n\nAvailable files: ${result.skill.availableFiles.join(', ')}${result.warnings && result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join('\n')}` : ''}`,
-            },
-        };
-    });
-}
-async function listSkills(input, context) {
-    return withSkillContext(context, async (skillContext) => {
-        const result = await coreListSkills(input, skillContext);
-        const skillsList = result.skills
-            .map((skill) => {
-            const sourceIcon = SOURCE_ICONS[skill.source];
-            return `${sourceIcon} **${skill.name}**: ${skill.description}`;
-        })
-            .join('\n');
-        return {
-            success: true,
-            message: {
-                type: 'text',
-                value: `Found ${result.total} skill${result.total === 1 ? '' : 's'}:\n\n${skillsList}`,
-            },
-        };
-    });
-}
-async function readSkillFile(input, context) {
-    return withSkillContext(context, async (skillContext) => {
-        const result = await coreReadSkillFile(input, skillContext);
-        if (!result.success || !result.content) {
-            return {
-                success: false,
-                message: { type: 'error-text', value: result.error ?? 'Failed to read skill file' },
-            };
-        }
-        return {
-            success: true,
-            message: { type: 'text', value: result.content },
-        };
-    });
-}
-const localToolHandlers = {
-    runAgent,
-    createPullRequest,
-    createCommit,
-    printChangeFile,
-    confirm,
-    input,
-    select,
-    // Note: writeToFile and readFile removed to use core implementations with safety features
-    executeCommand,
-    generateText,
-    invokeTool,
-    taskEvent,
-    getMemoryContext,
-    // Note: readMemory, listMemoryTopics, updateMemory removed to use proper tool implementations
-    // from tools/ directory that return proper XML formatted responses
-    listTodoItems,
-    getTodoItem,
-    updateTodoItem,
-    loadSkill,
-    listSkills,
-    readSkillFile,
-};
-// Export local tool names for Proxy existence checks
-export const localToolNames = Object.keys(localToolHandlers);
-export async function toolCall(toolCall, context) {
-    // Check localToolHandlers first
-    const handler = localToolHandlers[toolCall.tool];
-    if (handler) {
-        // Runtime tool selection means TypeScript can't infer the correct input type
-        // We use 'as never' to bypass the type check since the actual type is validated at runtime
-        return handler(toolCall.input, context);
-    }
-    // Check MCP tools
-    if (context.parameters.mcpManager?.hasTool(toolCall.tool)) {
-        const input = typeof toolCall.input === 'object' && toolCall.input !== null && !Array.isArray(toolCall.input) ? toolCall.input : {};
-        try {
-            const result = await context.parameters.mcpManager.callTool(toolCall.tool, input);
-            // Wrap result in ToolResponse format
-            const value = typeof result === 'string' ? result : result == null ? '' : JSON.stringify(result, null, 2);
-            return {
-                success: true,
-                message: {
-                    type: 'text',
-                    value,
-                },
-            };
-        }
-        catch (error) {
-            // McpError should bubble up to the workflow level for proper handling
-            if (error instanceof McpError) {
-                throw error;
-            }
-            // Other errors are returned as ToolResponse so the agent can see them and recover
-            return {
-                success: false,
-                message: {
-                    type: 'error-text',
-                    value: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            };
-        }
-    }
-    // Check toolHandlers Map (for core/registered tools)
-    const toolHandler = toolHandlers.get(toolCall.tool);
-    if (toolHandler) {
-        // The tool handler expects specific input types based on the tool
-        // We cast to satisfy TypeScript since the exact type varies by tool
-        return toolHandler.handler(context.toolProvider, toolCall.input);
-    }
-    throw new Error(`Unknown tool: ${toolCall.tool}`);
-}
-/**
- * Create skill context for agent execution
- */
-export async function initializeSkillContext(cwd) {
-    return await createSkillContext(cwd);
-}
-/**
- * Generate system prompt with available skills
- */
-export function generateSystemPromptWithSkills(basePrompt, skillContext) {
-    if (!skillContext || skillContext.availableSkills.length === 0) {
-        return basePrompt;
-    }
-    const skillsPrompt = generateSkillsSystemPrompt(skillContext.availableSkills);
-    return basePrompt + skillsPrompt;
-}
-//# sourceMappingURL=tool-implementations.js.map