vibe-coder-mcp/build/tools/context-curator/types/llm-tasks.js

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import { z } from 'zod';
import { taskTypeSchema } from './context-curator.js';
export var ContextCuratorLLMTask;
(function (ContextCuratorLLMTask) {
    ContextCuratorLLMTask["INTENT_ANALYSIS"] = "context_curator_intent_analysis";
    ContextCuratorLLMTask["PROMPT_REFINEMENT"] = "context_curator_prompt_refinement";
    ContextCuratorLLMTask["FILE_DISCOVERY"] = "context_curator_file_discovery";
    ContextCuratorLLMTask["RELEVANCE_SCORING"] = "context_curator_relevance_scoring";
    ContextCuratorLLMTask["META_PROMPT_GENERATION"] = "context_curator_meta_prompt_generation";
    ContextCuratorLLMTask["ARCHITECTURAL_ANALYSIS"] = "context_curator_architectural_analysis";
})(ContextCuratorLLMTask || (ContextCuratorLLMTask = {}));
export const intentAnalysisResultSchema = z.object({
    taskType: taskTypeSchema,
    confidence: z.number().min(0).max(1),
    reasoning: z.array(z.string()).min(1, 'At least one reasoning item is required'),
    architecturalComponents: z.array(z.string()),
    scopeAssessment: z.object({
        complexity: z.enum(['simple', 'moderate', 'complex']),
        estimatedFiles: z.number().min(0),
        riskLevel: z.enum(['low', 'medium', 'high'])
    }),
    suggestedFocusAreas: z.array(z.string()),
    estimatedEffort: z.enum(['low', 'medium', 'high', 'very_high'])
});
export const fileDiscoveryResultSchema = z.object({
    relevantFiles: z.array(z.object({
        path: z.string().min(1),
        priority: z.enum(['high', 'medium', 'low']),
        reasoning: z.string().min(1),
        confidence: z.number().min(0).max(1),
        estimatedTokens: z.number().min(0),
        modificationLikelihood: z.enum(['very_high', 'high', 'medium', 'low', 'very_low'])
    })),
    totalFilesAnalyzed: z.number().min(0),
    processingTimeMs: z.number().min(0),
    searchStrategy: z.enum(['semantic_similarity', 'keyword_matching', 'semantic_and_keyword', 'structural_analysis', 'multi_strategy']),
    coverageMetrics: z.object({
        totalTokens: z.number().min(0),
        averageConfidence: z.number().min(0).max(1)
    })
});
export const promptRefinementResultSchema = z.object({
    refinedPrompt: z.string().min(1, 'Refined prompt cannot be empty'),
    enhancementReasoning: z.array(z.string()),
    addedContext: z.array(z.string()),
    originalLength: z.number().min(0),
    refinedLength: z.number().min(0),
    improvementScore: z.number().min(0).max(1),
    contextualEnhancements: z.array(z.string())
});
export const relevanceScoringResultSchema = z.object({
    fileScores: z.array(z.object({
        filePath: z.string().min(1),
        relevanceScore: z.number().min(0).max(1),
        confidence: z.number().min(0).max(1),
        reasoning: z.string().min(1),
        categories: z.array(z.string()).min(1, 'At least one category is required'),
        modificationLikelihood: z.enum(['very_high', 'high', 'medium', 'low', 'very_low']),
        estimatedTokens: z.number().min(0)
    })),
    overallMetrics: z.object({
        averageRelevance: z.number().min(0).max(1),
        totalFilesScored: z.number().min(0),
        highRelevanceCount: z.number().min(0),
        processingTimeMs: z.number().min(0)
    }),
    scoringStrategy: z.enum(['semantic_similarity', 'keyword_density', 'structural_importance', 'hybrid']),
    chunkingUsed: z.boolean().optional(),
    totalChunks: z.number().min(1).optional(),
    chunkSize: z.number().min(1).optional()
});
export const metaPromptGenerationResultSchema = z.object({
    systemPrompt: z.string().min(1, 'System prompt cannot be empty'),
    userPrompt: z.string().min(1, 'User prompt cannot be empty'),
    contextSummary: z.string().min(1, 'Context summary cannot be empty'),
    taskDecomposition: z.object({
        epics: z.array(z.object({
            id: z.string().min(1),
            title: z.string().min(1),
            description: z.string().min(1),
            estimatedComplexity: z.enum(['low', 'medium', 'high', 'very_high']),
            tasks: z.array(z.object({
                id: z.string().min(1),
                title: z.string().min(1),
                description: z.string().min(1),
                estimatedHours: z.number().min(0),
                dependencies: z.array(z.string()),
                subtasks: z.array(z.object({
                    id: z.string().min(1),
                    title: z.string().min(1),
                    description: z.string().min(1),
                    estimatedMinutes: z.number().min(0)
                }))
            }))
        }))
    }),
    guidelines: z.array(z.string()),
    estimatedComplexity: z.enum(['low', 'medium', 'high', 'very_high']),
    qualityScore: z.number().min(0).max(1),
    aiAgentResponseFormat: z.object({
        description: z.string().min(1),
        format: z.string().min(1),
        rules: z.array(z.string().min(1))
    }).optional()
});
export const architecturalAnalysisResultSchema = z.object({
    architecturalPatterns: z.array(z.string()),
    dependencies: z.array(z.object({
        name: z.string().min(1),
        version: z.string(),
        type: z.enum(['runtime', 'development', 'peer', 'optional']),
        importance: z.enum(['critical', 'important', 'optional', 'deprecated'])
    })),
    codeStructure: z.object({
        directories: z.array(z.string()),
        entryPoints: z.array(z.string()),
        configFiles: z.array(z.string())
    }),
    recommendations: z.array(z.string()),
    complexityAssessment: z.object({
        overall: z.enum(['low', 'medium', 'high', 'very_high']),
        factors: z.array(z.string()),
        score: z.number().min(0).max(1)
    })
});
export const llmTaskErrorSchema = z.object({
    task: z.nativeEnum(ContextCuratorLLMTask),
    message: z.string().min(1, 'Error message cannot be empty'),
    code: z.string().min(1),
    details: z.record(z.unknown()),
    recoverable: z.boolean()
});
export const validateIntentAnalysisResult = (result) => {
    try {
        intentAnalysisResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const validateFileDiscoveryResult = (result) => {
    try {
        fileDiscoveryResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const validatePromptRefinementResult = (result) => {
    try {
        promptRefinementResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const validateRelevanceScoringResult = (result) => {
    try {
        relevanceScoringResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const validateMetaPromptGenerationResult = (result) => {
    try {
        metaPromptGenerationResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const validateArchitecturalAnalysisResult = (result) => {
    try {
        architecturalAnalysisResultSchema.parse(result);
        return true;
    }
    catch {
        return false;
    }
};
export const getLLMTaskName = (task) => {
    return task;
};
export const validateLLMTaskResult = (task, result) => {
    switch (task) {
        case ContextCuratorLLMTask.INTENT_ANALYSIS:
            return validateIntentAnalysisResult(result);
        case ContextCuratorLLMTask.FILE_DISCOVERY:
            return validateFileDiscoveryResult(result);
        case ContextCuratorLLMTask.PROMPT_REFINEMENT:
            return validatePromptRefinementResult(result);
        case ContextCuratorLLMTask.RELEVANCE_SCORING:
            return validateRelevanceScoringResult(result);
        case ContextCuratorLLMTask.META_PROMPT_GENERATION:
            return validateMetaPromptGenerationResult(result);
        case ContextCuratorLLMTask.ARCHITECTURAL_ANALYSIS:
            return validateArchitecturalAnalysisResult(result);
        default:
            return false;
    }
};