workflow3/dist/utils.js

MCP Server for three-stage workflow prompt injection

import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { fileURLToPath } from 'url';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
export function getMCPWorkingDirectory() {
    console.error('🔍 [workflow3] ===== 获取MCP工作目录诊断开始 =====');
    console.error(`🔍 [workflow3] process.cwd(): ${process.cwd()}`);
    const workspacePaths = process.env.WORKSPACE_FOLDER_PATHS;
    console.error(`🔍 [workflow3] 策略1 - WORKSPACE_FOLDER_PATHS: ${workspacePaths || 'undefined'}`);
    if (workspacePaths) {
        try {
            const folders = JSON.parse(workspacePaths);
            if (Array.isArray(folders) && folders.length > 0) {
                const firstFolder = folders[0];
                if (isValidDirectory(firstFolder)) {
                    console.error(`🔍 [workflow3] 策略1成功: ${firstFolder}`);
                    return firstFolder;
                }
            }
        }
        catch {
            const firstPath = workspacePaths.split(path.delimiter)[0];
            if (firstPath && isValidDirectory(firstPath)) {
                console.error(`🔍 [workflow3] 策略1备用成功: ${firstPath}`);
                return firstPath;
            }
        }
    }
    const ideEnvVars = [
        'VSCODE_WORKSPACE_FOLDER',
        'VSCODE_CWD',
        'PROJECT_ROOT',
        'IDEA_INITIAL_DIRECTORY',
        'WEBSTORM_PROJECT_PATH'
    ];
    for (const envVar of ideEnvVars) {
        const envValue = process.env[envVar];
        console.error(`🔍 [workflow3] 策略2 - ${envVar}: ${envValue || 'undefined'}`);
        if (envValue && isValidDirectory(envValue)) {
            console.error(`🔍 [workflow3] 策略2成功: ${envValue}`);
            return envValue;
        }
    }
    const pwd = process.env.PWD;
    console.error(`🔍 [workflow3] 策略3 - PWD: ${pwd || 'undefined'}`);
    if (pwd && isValidDirectory(pwd) && pwd !== process.cwd()) {
        console.error(`🔍 [workflow3] 策略3成功: ${pwd}`);
        return pwd;
    }
    const projectRoot = findProjectRoot(process.cwd());
    console.error(`🔍 [workflow3] 策略4结果: ${projectRoot || 'null'}`);
    if (projectRoot && projectRoot !== process.cwd()) {
        console.error(`🔍 [workflow3] 策略4成功: ${projectRoot}`);
        return projectRoot;
    }
    const fallbackPath = process.cwd();
    console.error(`🔍 [workflow3] 策略5 - 回退到process.cwd(): ${fallbackPath}`);
    console.error('🔍 [workflow3] ===== 获取MCP工作目录诊断结束 =====');
    return fallbackPath;
}
function isValidDirectory(dir) {
    try {
        if (!dir || typeof dir !== 'string') {
            return false;
        }
        const resolvedDir = path.resolve(dir);
        const stat = fs.statSync(resolvedDir);
        return stat.isDirectory();
    }
    catch {
        return false;
    }
}
export function findProjectRoot(startDir = process.cwd()) {
    const projectMarkers = [
        'package.json',
        '.git',
        'yarn.lock',
        'pnpm-lock.yaml',
        'composer.json',
        'Cargo.toml',
        'go.mod',
        'pyproject.toml',
        'requirements.txt'
    ];
    let currentDir = path.resolve(startDir);
    const rootDir = path.parse(currentDir).root;
    while (currentDir !== rootDir) {
        const hasProjectMarker = projectMarkers.some(marker => {
            const markerPath = path.join(currentDir, marker);
            return fs.existsSync(markerPath);
        });
        if (hasProjectMarker) {
            return currentDir;
        }
        currentDir = path.dirname(currentDir);
    }
    return startDir;
}
export function getTemplateFilePath() {
    return path.join(__dirname, 'templates', 'workflow3.md');
}
export function readTemplateContent() {
    const templatePath = getTemplateFilePath();
    if (!fs.existsSync(templatePath)) {
        throw new Error(`Template file not found: ${templatePath}`);
    }
    return fs.readFileSync(templatePath, 'utf-8');
}
export function getOrCreateWorkflowFile() {
    try {
        const workflowFilePath = path.join(os.homedir(), '.workflow3.md');
        console.error(`🔍 [workflow3] 目标文件路径: ${workflowFilePath}`);
        handleLegacyWorkflowFile();
        if (fs.existsSync(workflowFilePath)) {
            console.error(`✅ [workflow3] 读取现有文件: ${workflowFilePath}`);
            return fs.readFileSync(workflowFilePath, 'utf-8');
        }
        else {
            console.error(`📝 [workflow3] 创建新文件: ${workflowFilePath}`);
            const defaultContent = readTemplateContent();
            fs.writeFileSync(workflowFilePath, defaultContent, 'utf-8');
            console.error(`✅ [workflow3] 文件创建成功: ${workflowFilePath}`);
            return defaultContent;
        }
    }
    catch (error) {
        console.error(`❌ [workflow3] 文件操作失败: ${error}`);
        console.error('🔄 [workflow3] 使用模板内容作为fallback');
        return readTemplateContent();
    }
}
function handleLegacyWorkflowFile() {
    try {
        const projectRoot = getMCPWorkingDirectory();
        const legacyFilePath = path.join(projectRoot, 'workflow3.md');
        if (fs.existsSync(legacyFilePath)) {
            const content = fs.readFileSync(legacyFilePath, 'utf-8');
            if (content.includes('本文件已失效')) {
                return;
            }
            const deprecationNotice = `# 注意：本文件已失效

本文件已失效，有效的文件路径已更改到 ~/.workflow3.md

请删除此文件，并在用户主目录的 ~/.workflow3.md 文件中进行配置。

---

`;
            const updatedContent = deprecationNotice + content;
            fs.writeFileSync(legacyFilePath, updatedContent, 'utf-8');
            console.error(`📝 [workflow3] 已在旧文件添加失效说明: ${legacyFilePath}`);
        }
    }
    catch (error) {
        console.error(`⚠️ [workflow3] 处理旧文件时出错: ${error}`);
    }
}
//# sourceMappingURL=utils.js.map