@agentdesk/workflows-mcp/dist/prompts.js

MCP workflow orchestration tool with presets for thinking, coding and more

import * as fs from "fs";
import * as path from "path";
import * as yaml from "js-yaml";
import { fileURLToPath } from "url";
import { dirname } from "path";
// In ES modules, __dirname is not available directly
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
// Directory where preset YAML files are stored
const PRESETS_DIR = path.join(__dirname, "presets");
/**
 * Applies configuration to a default prompt
 *
 * @param {string} defaultPrompt - The base prompt text to modify
 * @param {PromptConfig} [config] - Optional configuration to apply to the prompt
 * @returns {string} The final prompt with configuration applied
 */
const applyConfig = (defaultPrompt, config) => {
    if (!config) {
        return defaultPrompt;
    }
    // Use prompt if provided, otherwise use default
    let finalPrompt = config.prompt || defaultPrompt;
    // Append context if provided
    if (config.context) {
        finalPrompt += `\n\n${config.context}`;
    }
    // Add tools section if tools are provided
    if (config.tools && config.tools.length > 0) {
        finalPrompt += `\n\n## Available Tools\n`;
        if (config.toolMode === "sequential") {
            finalPrompt += "Follow this sequence of tools to complete the task:\n\n";
            config.tools.forEach((tool, index) => {
                finalPrompt += `${index + 1}. **${tool.name}**`;
                if (tool.description) {
                    finalPrompt += `: ${tool.description}`;
                }
                finalPrompt += "\n";
            });
        }
        else {
            // Default to situational mode
            finalPrompt += "You can use these tools as needed:\n\n";
            config.tools.forEach((tool) => {
                finalPrompt += `- **${tool.name}**`;
                if (tool.description) {
                    finalPrompt += `: ${tool.description}`;
                }
                finalPrompt += "\n";
            });
        }
    }
    return finalPrompt;
};
/**
 * Discovers and loads all YAML configuration files in the presets directory
 *
 * @returns {Record<string, any>} An object mapping preset names to their configuration objects
 * @throws Will log an error if there are issues reading the directory or parsing YAML files
 */
function discoverPresetConfigs() {
    const presetConfigs = {};
    try {
        // Get all YAML files in the presets directory
        const presetFiles = fs
            .readdirSync(PRESETS_DIR)
            .filter((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
        // Load each preset file
        for (const presetFile of presetFiles) {
            const presetPath = path.join(PRESETS_DIR, presetFile);
            const presetName = path.basename(presetFile, path.extname(presetFile));
            try {
                const content = fs.readFileSync(presetPath, "utf-8");
                const presetConfig = yaml.load(content);
                // Store the configuration with the preset file name as the key
                presetConfigs[presetName] = presetConfig;
            }
            catch (error) {
                console.error(`Error loading preset file ${presetFile}:`, error);
            }
        }
    }
    catch (error) {
        console.error("Error discovering preset configurations:", error);
    }
    return presetConfigs;
}
/**
 * Creates a prompt generation function for a specific mode and preset
 *
 * @param {string} modeName - The name of the mode to create a prompt function for
 * @param {string} presetName - The name of the preset configuration to use
 * @param {Record<string, any>} presetConfigs - Object containing all loaded preset configurations
 * @returns {(config?: DevToolsConfig) => string} A function that generates a prompt based on the mode and preset
 */
function createPromptFunction(modeName, presetName, presetConfigs) {
    return (config) => {
        try {
            const presetConfig = presetConfigs[presetName];
            if (presetConfig && presetConfig[modeName]?.prompt) {
                return applyConfig(presetConfig[modeName].prompt, config?.[modeName]);
            }
        }
        catch (error) {
            console.error(`Error generating prompt for ${modeName} from ${presetName}:`, error);
        }
        // Fallback if preset prompt not found
        return `# ${modeName
            .replace(/_/g, " ")
            .replace(/\b\w/g, (l) => l.toUpperCase())}\n\nNo default prompt found for this tool.`;
    };
}
// Discover all preset configurations
const presetConfigs = discoverPresetConfigs();
// Object to store prompt functions for all modes
const promptFunctions = {};
/**
 * Initializes prompt functions by processing all discovered preset configurations
 * @returns Record of prompt functions indexed by mode name
 */
function initializePromptFunctions() {
    // Process each preset file
    Object.entries(presetConfigs).forEach(([presetName, presetConfig]) => {
        // Process each mode in the preset
        Object.keys(presetConfig).forEach((modeName) => {
            // Register the prompt function for this mode
            promptFunctions[modeName] = createPromptFunction(modeName, presetName, presetConfigs);
        });
    });
    return promptFunctions;
}
// Initialize prompt functions on module load
initializePromptFunctions();
export { promptFunctions, initializePromptFunctions };
//# sourceMappingURL=prompts.js.map