@razorpay/blade-mcp/dist/tools/createBladeCursorRules.js

Model Context Protocol server for Blade

import { join, basename } from 'path';
import { existsSync, unlinkSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
import { z } from 'zod';
import { BLADE_CURSOR_RULES_FILE_PATH, CURSOR_RULES_VERSION, analyticsToolCallEventName, } from '../utils/tokens.js';
import { hasOutDatedRules } from '../utils/generalUtils.js';
import { handleError, sendAnalytics } from '../utils/analyticsUtils.js';
// eslint-disable-next-line import/no-cycle
import { cursorRuleCreationInstructions } from '../utils/cursorRulesUtils.js';
const createBladeCursorRulesToolName = 'create_blade_cursor_rules';
const createBladeCursorRulesToolDescription = 'Creates the cursor rules for blade to help with code generation. Returns the bash script that should be executed. while creating a new blade project (only when using cursor and when the frontend-blade-rules.mdc rule does not already exist).';
// Schema for stdio transport
const createBladeCursorRulesToolSchema = {
    currentProjectRootDirectory: z
        .string()
        .describe("The working root directory of the consumer's project. Do not use root directory, do not use '.', only use absolute path to current directory"),
};
// Core business logic function
const createBladeCursorRulesCore = ({ currentProjectRootDirectory, isHttpTransport = false, }) => {
    try {
        // For HTTP transport, return instructions instead of creating the file directly
        if (isHttpTransport) {
            sendAnalytics({
                eventName: analyticsToolCallEventName,
                properties: {
                    toolName: createBladeCursorRulesToolName,
                    cursorRulesVersion: CURSOR_RULES_VERSION,
                    rootDirectoryName: basename(currentProjectRootDirectory),
                },
            });
            return {
                content: [
                    {
                        type: 'text',
                        text: cursorRuleCreationInstructions({ currentProjectRootDirectory }),
                    },
                ],
            };
        }
        const ruleFileDir = join(currentProjectRootDirectory, '.cursor/rules');
        const ruleFilePath = join(ruleFileDir, 'frontend-blade-rules.mdc');
        if (existsSync(ruleFilePath)) {
            if (hasOutDatedRules(ruleFilePath)) {
                // removes the outdated rules file and continues execution to generate new rule file
                unlinkSync(ruleFilePath);
            }
            else {
                return {
                    content: [{ type: 'text', text: 'Cursor rules already exist. Doing nothing' }],
                };
            }
        }
        const ruleFileTemplateContent = readFileSync(BLADE_CURSOR_RULES_FILE_PATH, 'utf8');
        if (!existsSync(ruleFileDir)) {
            mkdirSync(ruleFileDir, { recursive: true });
        }
        writeFileSync(ruleFilePath, ruleFileTemplateContent);
        sendAnalytics({
            eventName: analyticsToolCallEventName,
            properties: {
                toolName: createBladeCursorRulesToolName,
                cursorRulesVersion: CURSOR_RULES_VERSION,
                rootDirectoryName: basename(currentProjectRootDirectory),
            },
        });
        return {
            content: [
                {
                    type: 'text',
                    text: `Blade cursor rules created at: ${ruleFilePath}. Cursor Rules Version: ${CURSOR_RULES_VERSION}`,
                },
            ],
        };
    }
    catch (error) {
        return handleError({
            toolName: createBladeCursorRulesToolName,
            errorObject: error,
        });
    }
};
// Callback for stdio transport
const createBladeCursorRulesStdioCallback = ({ currentProjectRootDirectory }) => {
    return createBladeCursorRulesCore({
        currentProjectRootDirectory,
        isHttpTransport: false,
    });
};
// Callback for HTTP transport
const createBladeCursorRulesHttpCallback = ({ currentProjectRootDirectory, }) => {
    return createBladeCursorRulesCore({
        currentProjectRootDirectory,
        isHttpTransport: true,
    });
};
export { createBladeCursorRulesToolName, createBladeCursorRulesToolDescription, createBladeCursorRulesToolSchema, createBladeCursorRulesStdioCallback, createBladeCursorRulesHttpCallback, };
//# sourceMappingURL=createBladeCursorRules.js.map