mcp-chain-of-thought/dist/prompts/generators/executeTask.js

Chain of Thought is a tool built for AI Agents, emphasizing chain-of-thought, reflection, and style consistency. It converts natural language into structured dev tasks with dependency tracking and iterative refinement, enabling agent-like developer behavi

/**
 * executeTask prompt generator
 * Responsible for combining templates and parameters into the final prompt
 */
import { loadPrompt, generatePrompt, loadPromptFromTemplate, } from "../loader.js";
import { TaskStatus } from "../../types/index.js";
/**
 * Get styled text for complexity level
 * @param level complexity level
 * @returns styled text
 */
function getComplexityStyle(level) {
    switch (level) {
        case "VERY_HIGH":
            return "⚠️ **Warning: This task has extremely high complexity** ⚠️";
        case "HIGH":
            return "⚠️ **Note: This task has high complexity**";
        case "MEDIUM":
            return "**Tip: This task has moderate complexity**";
        default:
            return "";
    }
}
/**
 * Get complexity-based guidance for subtask evaluation
 * @param level complexity level
 * @returns guidance text
 */
function getComplexityBasedGuidance(level) {
    switch (level) {
        case "VERY_HIGH":
            return "⚠️ This task has very high complexity. It is strongly recommended to split it into multiple subtasks. You should have compelling reasons if you choose not to split this task.";
        case "HIGH":
            return "This task has high complexity. Strongly consider splitting it into smaller subtasks for better manageability and reduced risk. If you decide not to split, you must justify your decision.";
        case "MEDIUM":
            return "This task has moderate complexity. Consider if there are natural boundaries for splitting, but proceeding with a single task may be appropriate.";
        default: // LOW
            return "This task appears to be low complexity. Splitting is typically not necessary unless you identify specific reasons.";
    }
}
/**
 * Get the complete executeTask prompt
 * @param params prompt parameters
 * @returns generated prompt
 */
export function getExecuteTaskPrompt(params) {
    const { task, complexityAssessment, relatedFilesSummary, dependencyTasks } = params;
    const notesTemplate = loadPromptFromTemplate("executeTask/notes.md");
    let notesPrompt = "";
    if (task.notes) {
        notesPrompt = generatePrompt(notesTemplate, {
            notes: task.notes,
        });
    }
    const implementationGuideTemplate = loadPromptFromTemplate("executeTask/implementationGuide.md");
    let implementationGuidePrompt = "";
    if (task.implementationGuide) {
        implementationGuidePrompt = generatePrompt(implementationGuideTemplate, {
            implementationGuide: task.implementationGuide,
        });
    }
    const verificationCriteriaTemplate = loadPromptFromTemplate("executeTask/verificationCriteria.md");
    let verificationCriteriaPrompt = "";
    if (task.verificationCriteria) {
        verificationCriteriaPrompt = generatePrompt(verificationCriteriaTemplate, {
            verificationCriteria: task.verificationCriteria,
        });
    }
    const analysisResultTemplate = loadPromptFromTemplate("executeTask/analysisResult.md");
    let analysisResultPrompt = "";
    if (task.analysisResult) {
        analysisResultPrompt = generatePrompt(analysisResultTemplate, {
            analysisResult: task.analysisResult,
        });
    }
    const dependencyTasksTemplate = loadPromptFromTemplate("executeTask/dependencyTasks.md");
    let dependencyTasksPrompt = "";
    if (dependencyTasks && dependencyTasks.length > 0) {
        const completedDependencyTasks = dependencyTasks.filter((t) => t.status === TaskStatus.COMPLETED && t.summary);
        if (completedDependencyTasks.length > 0) {
            let dependencyTasksContent = "";
            for (const depTask of completedDependencyTasks) {
                dependencyTasksContent += `### ${depTask.name}\n${depTask.summary || "*No completion summary*"}\n\n`;
            }
            dependencyTasksPrompt = generatePrompt(dependencyTasksTemplate, {
                dependencyTasks: dependencyTasksContent,
            });
        }
    }
    const relatedFilesSummaryTemplate = loadPromptFromTemplate("executeTask/relatedFilesSummary.md");
    let relatedFilesSummaryPrompt = "";
    relatedFilesSummaryPrompt = generatePrompt(relatedFilesSummaryTemplate, {
        relatedFilesSummary: relatedFilesSummary || "The current task has no related files.",
    });
    const complexityTemplate = loadPromptFromTemplate("executeTask/complexity.md");
    let complexityPrompt = "";
    if (complexityAssessment) {
        const complexityStyle = getComplexityStyle(complexityAssessment.level);
        let recommendationContent = "";
        if (complexityAssessment.recommendations &&
            complexityAssessment.recommendations.length > 0) {
            for (const recommendation of complexityAssessment.recommendations) {
                recommendationContent += `- ${recommendation}\n`;
            }
        }
        complexityPrompt = generatePrompt(complexityTemplate, {
            level: complexityAssessment.level,
            complexityStyle: complexityStyle,
            descriptionLength: complexityAssessment.metrics.descriptionLength,
            dependenciesCount: complexityAssessment.metrics.dependenciesCount,
            recommendation: recommendationContent,
        });
    }
    const subtaskEvaluationTemplate = loadPromptFromTemplate("executeTask/subtaskEvaluation.md");
    let subtaskEvaluationPrompt = "";
    if (complexityAssessment) {
        const complexityBasedGuidance = getComplexityBasedGuidance(complexityAssessment.level);
        subtaskEvaluationPrompt = generatePrompt(subtaskEvaluationTemplate, {
            complexityBasedGuidance,
        });
    }
    else {
        // Default guidance if complexity assessment is missing
        subtaskEvaluationPrompt = generatePrompt(subtaskEvaluationTemplate, {
            complexityBasedGuidance: "Unable to determine task complexity. Evaluate the task based on your understanding and the assessment criteria.",
        });
    }
    const indexTemplate = loadPromptFromTemplate("executeTask/index.md");
    let prompt = generatePrompt(indexTemplate, {
        name: task.name,
        id: task.id,
        description: task.description,
        notesTemplate: notesPrompt,
        implementationGuideTemplate: implementationGuidePrompt,
        verificationCriteriaTemplate: verificationCriteriaPrompt,
        analysisResultTemplate: analysisResultPrompt,
        dependencyTasksTemplate: dependencyTasksPrompt,
        relatedFilesSummaryTemplate: relatedFilesSummaryPrompt,
        complexityTemplate: complexityPrompt,
        subtaskEvaluationTemplate: subtaskEvaluationPrompt,
    });
    // Load possible custom prompt
    return loadPrompt(prompt, "EXECUTE_TASK");
}
//# sourceMappingURL=executeTask.js.map