ai-expert/dist/services/expert-builder.js

AI Expert CLI - Advanced management system for specialized Claude assistants

export class ExpertBuilder {
    storage;
    constructor(storage) {
        this.storage = storage;
    }
    async buildExpertPrompt(expert) {
        let systemPrompt = '';
        // 1. Get base system from context or expert
        if (expert.baseSystemId) {
            const system = await this.storage.getSystem(expert.baseSystemId);
            if (system) {
                systemPrompt = system.content;
            }
        }
        else if (expert.baseContextId) {
            const context = await this.storage.getContext(expert.baseContextId);
            if (context?.systemTemplateId) {
                const system = await this.storage.getSystem(context.systemTemplateId);
                if (system) {
                    systemPrompt = system.content;
                }
            }
        }
        // 2. Apply context rules and content
        if (expert.baseContextId) {
            const context = await this.storage.getContext(expert.baseContextId);
            if (context) {
                systemPrompt = await this.applyContext(systemPrompt, context);
            }
        }
        // 3. Apply expert-specific rules
        if (expert.additionalRules.length > 0) {
            systemPrompt += '\n\nREGRAS ESPECÍFICAS DO ESPECIALISTA:';
            for (const rule of expert.additionalRules) {
                systemPrompt += `\n- ${rule.content}`;
            }
        }
        // 4. Add expert-specific context
        if (expert.additionalContext) {
            systemPrompt = this.addAdditionalContext(systemPrompt, expert.additionalContext);
        }
        return systemPrompt;
    }
    async applyContext(basePrompt, context) {
        let prompt = basePrompt;
        // Add rules
        if (context.rules.length > 0) {
            prompt += '\n\nREGRAS DO CONTEXTO:';
            for (const rule of context.rules) {
                prompt += `\n- [${rule.category.toUpperCase()}] ${rule.content}`;
            }
        }
        // Add concepts
        if (context.concepts.length > 0) {
            prompt += '\n\nCONCEITOS:';
            for (const concept of context.concepts) {
                prompt += `\n- ${concept}`;
            }
        }
        // Add patterns
        if (context.patterns.length > 0) {
            prompt += '\n\nPADRÕES:';
            for (const pattern of context.patterns) {
                prompt += `\n- ${pattern}`;
            }
        }
        // Add examples
        if (context.examples.length > 0) {
            prompt += '\n\nEXEMPLOS:';
            for (const example of context.examples) {
                prompt += `\n\n### ${example.name}`;
                if (example.description) {
                    prompt += `\n${example.description}`;
                }
                prompt += `\n\`\`\`${example.language || ''}\n${example.code}\n\`\`\``;
            }
        }
        // Add custom variables
        if (context.customVariables && Object.keys(context.customVariables).length > 0) {
            prompt += `\n\nVARIÁVEIS CUSTOMIZADAS:\n${JSON.stringify(context.customVariables, null, 2)}`;
        }
        return prompt;
    }
    addAdditionalContext(prompt, additionalContext) {
        let result = prompt;
        if (additionalContext.concepts.length > 0) {
            result += '\n\nCONCEITOS ADICIONAIS:';
            for (const concept of additionalContext.concepts) {
                result += `\n- ${concept}`;
            }
        }
        if (additionalContext.patterns.length > 0) {
            result += '\n\nPADRÕES ADICIONAIS:';
            for (const pattern of additionalContext.patterns) {
                result += `\n- ${pattern}`;
            }
        }
        if (additionalContext.examples.length > 0) {
            result += '\n\nEXEMPLOS ADICIONAIS:';
            for (const example of additionalContext.examples) {
                result += `\n\n### ${example.name}`;
                if (example.description) {
                    result += `\n${example.description}`;
                }
                result += `\n\`\`\`${example.language || ''}\n${example.code}\n\`\`\``;
            }
        }
        if (additionalContext.customVariables && Object.keys(additionalContext.customVariables).length > 0) {
            result += `\n\nVARIÁVEIS ADICIONAIS:\n${JSON.stringify(additionalContext.customVariables, null, 2)}`;
        }
        return result;
    }
    async createExpert(name, description, options = {}) {
        const slug = name.toLowerCase().replace(/\s+/g, '-');
        const id = `${slug}-${Date.now()}`;
        const expert = {
            id,
            name,
            slug,
            description,
            baseContextId: options.baseContextId,
            baseSystemId: options.baseSystemId,
            systemPrompt: '', // Will be computed
            additionalRules: options.additionalRules || [],
            additionalContext: {
                concepts: [],
                patterns: [],
                examples: [],
                customVariables: {}
            },
            category: options.category || 'custom',
            tags: options.tags || [],
            created: new Date().toISOString(),
            usageCount: 0
        };
        // Build the system prompt
        expert.systemPrompt = await this.buildExpertPrompt(expert);
        // Save the expert
        await this.storage.saveExpert(expert);
        return expert;
    }
}
//# sourceMappingURL=expert-builder.js.map