executeTask.ts•6.88 kB
/**
* executeTask prompt generator
* Responsible for combining templates and parameters into the final prompt
*/
import {
loadPrompt,
generatePrompt,
loadPromptFromTemplate,
} from "../loader.js";
import { Task, TaskStatus } from "../../types/index.js";
/**
* Task complexity assessment interface
*/
interface ComplexityAssessment {
level: string;
metrics: {
descriptionLength: number;
dependenciesCount: number;
};
recommendations?: string[];
}
/**
* executeTask prompt parameter interface
*/
export interface ExecuteTaskPromptParams {
task: Task;
complexityAssessment?: ComplexityAssessment;
relatedFilesSummary?: string;
dependencyTasks?: Task[];
}
/**
* Get styled text for complexity level
* @param level complexity level
* @returns styled text
*/
function getComplexityStyle(level: string): string {
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: string): string {
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: ExecuteTaskPromptParams): string {
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");
}