dev-mcp-server 0.0.2 → 1.0.0

package/src/planner/plannerEngine.js

@@ -0,0 +1,202 @@
+/**
+ * Plan Mode: Before executing a complex change, generate a step-by-step plan
+ *            and get user approval before proceeding.
+ *
+ * Compact:   Compress long conversation history into a dense summary
+ *            to stay within context limits.
+ */
+
+const llm = require('../utils/llmClient');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+
+class PlannerEngine {
+    /**
+     * Generate an execution plan for a complex task.
+     * This is the "think before you act" pattern.
+     *
+     * @param {string} task - What the user wants to do
+     * @param {Array}  context - Retrieved codebase chunks
+     * @param {string} sessionId
+     */
+    async generatePlan(task, context = [], sessionId = 'default') {
+        const contextStr = context.length > 0
+            ? `\n\n## Relevant Codebase Context\n${context.map(c => `**${c.filename}**:\n${c.content.slice(0, 800)}`).join('\n\n---\n\n')}`
+            : '';
+
+        const response = await llm.chat({
+            model: llm.model('smart'),
+            max_tokens: 1500,
+            system: `You are a senior developer creating an execution plan. Be specific, step-by-step, and honest about risks.
+Format the plan as:
+
+## Understanding
+(What you understand about the task and codebase context)
+
+## Plan
+Step 1: [action] — [file/component affected] — [risk: low|medium|high]
+Step 2: ...
+...
+
+## Prerequisites
+(Anything that needs to happen before starting)
+
+## Risks & Rollback
+(What could go wrong and how to undo it)
+
+## Estimated Effort
+(Quick estimate: minutes/hours)`,
+            messages: [{
+                role: 'user',
+                content: `Create an execution plan for this task:\n\n${task}${contextStr}`,
+            }],
+        });
+
+        costTracker.record({
+            model: llm.model('smart'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: 'plan',
+        });
+
+        return {
+            task,
+            plan: response.content[0].text,
+            generatedAt: new Date().toISOString(),
+            approved: false,
+        };
+    }
+
+    /**
+     * Compact a conversation history into a dense summary.
+     * Reduces token usage by replacing old messages with a compressed summary.
+     *
+     * @param {Array} messages - Array of { role, content } message objects
+     * @param {string} sessionId
+     */
+    async compact(messages, sessionId = 'default') {
+        if (!messages || messages.length < 4) {
+            return { compacted: false, reason: 'Too few messages to compact', messages };
+        }
+
+        // Keep last 2 messages verbatim, compact the rest
+        const toCompact = messages.slice(0, -2);
+        const toKeep = messages.slice(-2);
+
+        const historyText = toCompact.map(m =>
+            `${m.role.toUpperCase()}: ${m.content?.slice(0, 500) || ''}`
+        ).join('\n\n');
+
+        const response = await llm.chat({
+            model: llm.model('fast'),
+            max_tokens: 800,
+            messages: [{
+                role: 'user',
+                content: `Compress this conversation history into a dense, information-preserving summary that captures:
+1. What was asked and answered
+2. Key facts discovered about the codebase
+3. Any decisions made or actions taken
+4. Open questions or unresolved issues
+
+Keep it under 400 words. Be specific (include file names, function names, error types).
+
+History to compress:
+${historyText}`,
+            }],
+        });
+
+        costTracker.record({
+            model: llm.model('fast'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: 'compact',
+        });
+
+        const summary = response.content[0].text;
+        const compactedMessage = {
+            role: 'system',
+            content: `[Compacted conversation summary]\n${summary}`,
+            compacted: true,
+            originalCount: toCompact.length,
+            compactedAt: new Date().toISOString(),
+        };
+
+        const compactedMessages = [compactedMessage, ...toKeep];
+
+        logger.info(`[Compact] ${messages.length} messages → ${compactedMessages.length} (${toCompact.length} compacted)`);
+
+        return {
+            compacted: true,
+            originalCount: messages.length,
+            newCount: compactedMessages.length,
+            savedMessages: messages.length - compactedMessages.length,
+            messages: compactedMessages,
+            summary,
+        };
+    }
+
+    /**
+     * Doctor — check environment health
+     */
+    async doctor() {
+        const checks = [];
+        const BashTool = require('../tools/BashTool');
+
+        const run = async (name, cmd, parse) => {
+            try {
+                const r = await BashTool.executeOrThrow(cmd, {});
+                checks.push({ name, status: 'ok', detail: parse ? parse(r.stdout) : r.stdout.trim() });
+            } catch (err) {
+                checks.push({ name, status: 'fail', detail: err.message.slice(0, 100) });
+            }
+        };
+
+        await run('Node.js', 'node --version', v => v.trim());
+        await run('npm', 'npm --version', v => `v${v.trim()}`);
+        await run('git', 'git --version', v => v.trim());
+        await run('ripgrep', 'rg --version', v => v.split('\n')[0]);
+
+        // Check API key
+        // checks.push({
+        //     name: 'ANTHROPIC_API_KEY',
+        //     status: process.env.ANTHROPIC_API_KEY ? 'ok' : 'fail',
+        //     detail: process.env.ANTHROPIC_API_KEY
+        //         ? `Set (${process.env.ANTHROPIC_API_KEY.slice(0, 10)}...)`
+        //         : 'Not set — add to .env',
+        // });
+
+        // Check data directory
+        const fs = require('fs');
+        const dataDir = require('path').join(process.cwd(), 'data');
+        checks.push({
+            name: 'data/ directory',
+            status: fs.existsSync(dataDir) ? 'ok' : 'warn',
+            detail: fs.existsSync(dataDir) ? 'Exists' : 'Will be created on first ingest',
+        });
+
+        // Knowledge base
+        const store = require('../storage/store');
+        const stats = store.getStats();
+        checks.push({
+            name: 'Knowledge base',
+            status: stats.totalDocs > 0 ? 'ok' : 'warn',
+            detail: stats.totalDocs > 0
+                ? `${stats.totalDocs} docs from ${stats.totalFiles} files`
+                : 'Empty — run: node cli.js ingest <path>',
+        });
+
+        const passed = checks.filter(c => c.status === 'ok').length;
+        const failed = checks.filter(c => c.status === 'fail').length;
+        const warned = checks.filter(c => c.status === 'warn').length;
+
+        return {
+            checks,
+            summary: { passed, failed, warned, total: checks.length },
+            healthy: failed === 0,
+        };
+    }
+}
+
+module.exports = new PlannerEngine();

package/src/plugins/builtin/stats-plugin.js

@@ -0,0 +1,29 @@
+'use strict';
+/**
+ * Built-in plugin: stats-plugin
+ * Adds /api/stats/overview — a single endpoint that aggregates everything.
+ */
+module.exports = {
+    name: 'stats-plugin',
+    version: '1.0.0',
+    description: 'Adds /api/stats/overview endpoint aggregating all system stats',
+    async register(app, { store, toolRegistry }) {
+        app.get('/api/stats/overview', async (req, res) => {
+            try {
+                const kbStats = store ? store.getStats() : {};
+                const { MemoryManager } = require('../../memory/memoryManager');
+                const { TaskManager } = require('../../tasks/taskManager');
+                const costTracker = require('../../utils/costTracker');
+                res.json({
+                    version: '1.0.0',
+                    knowledgeBase: kbStats,
+                    memory: MemoryManager.getStats(),
+                    tasks: TaskManager.getStats(),
+                    cost: costTracker.getSummary(),
+                    tools: toolRegistry ? toolRegistry.count : 0,
+                    uptime: process.uptime(),
+                });
+            } catch (e) { res.status(500).json({ error: e.message }); }
+        });
+    },
+};

package/src/plugins/pluginManager.js

@@ -0,0 +1,144 @@
+'use strict';
+/**
+ * A plugin is a plain Node module that exports:
+ *   { name, version, description, register(app, registry) }
+ *
+ * register() receives:
+ *   - app           : Express app (add routes)
+ *   - toolRegistry  : add custom tools
+ *   - app._mcpCtx   : shared context (store, indexer, memory, etc.)
+ *
+ * Built-in plugins ship in src/plugins/builtin/.
+ * User plugins drop into <cwd>/plugins/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+
+const BUILTIN_DIR = path.join(__dirname, 'builtin');
+const USER_DIR = path.join(process.cwd(), 'plugins');
+const STATE_FILE = path.join(process.cwd(), 'data', 'plugins-state.json');
+
+class PluginManager {
+    constructor() {
+        this._plugins = new Map();   // name → { meta, enabled, instance }
+        this._state = this._loadState();
+        this._app = null;
+        this._ctx = null;
+    }
+
+    _loadState() {
+        try { if (fs.existsSync(STATE_FILE)) return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')); } catch { }
+        return { disabled: [] };
+    }
+    _saveState() { fs.writeFileSync(STATE_FILE, JSON.stringify(this._state, null, 2)); }
+
+    /**
+     * Load and register all plugins. Called once during server boot.
+     * @param {Express} app
+     * @param {object}  ctx  — { toolRegistry, store, indexer, memoryManager, ... }
+     */
+    async loadAll(app, ctx = {}) {
+        this._app = app;
+        this._ctx = ctx;
+
+        // Load built-in plugins first
+        if (fs.existsSync(BUILTIN_DIR)) {
+            for (const file of fs.readdirSync(BUILTIN_DIR).filter(f => f.endsWith('.js'))) {
+                await this._load(path.join(BUILTIN_DIR, file), true);
+            }
+        }
+
+        // Load user plugins
+        if (fs.existsSync(USER_DIR)) {
+            for (const file of fs.readdirSync(USER_DIR).filter(f => f.endsWith('.js'))) {
+                await this._load(path.join(USER_DIR, file), false);
+            }
+        }
+
+        logger.info(`[Plugins] Loaded ${this._plugins.size} plugin(s): ${[...this._plugins.keys()].join(', ') || 'none'}`);
+    }
+
+    async _load(filePath, builtIn = false) {
+        try {
+            const mod = require(filePath);
+            const name = mod.name || path.basename(filePath, '.js');
+            const enabled = !this._state.disabled.includes(name);
+
+            const entry = {
+                name,
+                version: mod.version || '1.0.0',
+                description: mod.description || '',
+                filePath,
+                builtIn,
+                enabled,
+                loadedAt: new Date().toISOString(),
+                error: null,
+            };
+
+            if (enabled && typeof mod.register === 'function') {
+                try {
+                    await mod.register(this._app, {
+                        toolRegistry: this._ctx.toolRegistry,
+                        ...this._ctx,
+                    });
+                    logger.info(`[Plugins] ✓ ${name}${builtIn ? ' (built-in)' : ''}`);
+                } catch (err) {
+                    entry.error = err.message;
+                    logger.error(`[Plugins] ✗ ${name}: ${err.message}`);
+                }
+            }
+
+            this._plugins.set(name, entry);
+        } catch (err) {
+            logger.warn(`[Plugins] Could not load ${filePath}: ${err.message}`);
+        }
+    }
+
+    /**
+     * Load a single plugin by file path (hot-load at runtime)
+     */
+    async loadPlugin(filePath) {
+        delete require.cache[require.resolve(filePath)];
+        await this._load(filePath);
+        return this.get(path.basename(filePath, '.js'));
+    }
+
+    enable(name) {
+        const p = this._plugins.get(name);
+        if (!p) throw new Error(`Plugin not found: ${name}`);
+        this._state.disabled = this._state.disabled.filter(n => n !== name);
+        p.enabled = true;
+        this._saveState();
+        return p;
+    }
+
+    disable(name) {
+        const p = this._plugins.get(name);
+        if (!p) throw new Error(`Plugin not found: ${name}`);
+        if (!this._state.disabled.includes(name)) this._state.disabled.push(name);
+        p.enabled = false;
+        this._saveState();
+        logger.info(`[Plugins] Disabled: ${name} (restart to fully unload)`);
+        return p;
+    }
+
+    list() {
+        return [...this._plugins.values()].map(({ filePath, ...rest }) => rest);
+    }
+
+    get(name) {
+        const p = this._plugins.get(name);
+        if (!p) return null;
+        const { filePath, ...rest } = p;
+        return rest;
+    }
+
+    getStats() {
+        const all = this.list();
+        return { total: all.length, enabled: all.filter(p => p.enabled).length, disabled: all.filter(p => !p.enabled).length, errors: all.filter(p => p.error).length };
+    }
+}
+
+module.exports = new PluginManager();

package/src/prompts/promptEngineer.js

@@ -0,0 +1,289 @@
+'use strict';
+/**
+ * A dedicated prompt engineering system.
+ *
+ * Features:
+ *   - Analyse a prompt for weaknesses
+ *   - Improve a prompt automatically
+ *   - Generate prompts from a task description
+ *   - A/B test two prompts against a benchmark
+ *   - Prompt template library with variables
+ *   - Chain-of-thought injection
+ */
+
+const llm = require('../utils/llmClient');
+const fs = require('fs');
+const path = require('path');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+
+const LIBRARY_FILE = path.join(process.cwd(), 'data', 'prompt-library.json');
+
+// ── Built-in prompt templates ─────────────────────────────────────────────────
+const BUILTIN_TEMPLATES = {
+    'chain-of-thought': {
+        name: 'chain-of-thought',
+        description: 'Adds structured reasoning steps before the answer',
+        template: `{prompt}
+
+Think through this step by step:
+1. What is being asked?
+2. What information do I have?
+3. What approach should I take?
+4. Work through the solution
+5. Verify the answer
+
+Answer:`,
+        variables: ['prompt'],
+    },
+    'role-expert': {
+        name: 'role-expert',
+        description: 'Frame Anu as a domain expert',
+        template: `You are a world-class {domain} expert with 20+ years of experience.
+You give precise, evidence-based answers grounded in real-world practice.
+You never guess — if you are uncertain, you say so clearly.
+
+Task: {task}`,
+        variables: ['domain', 'task'],
+    },
+    'few-shot': {
+        name: 'few-shot',
+        description: 'Provide examples before the actual task',
+        template: `Here are examples of the task:
+
+Example 1:
+Input: {example1_input}
+Output: {example1_output}
+
+Example 2:
+Input: {example2_input}
+Output: {example2_output}
+
+Now do the same for:
+Input: {actual_input}
+Output:`,
+        variables: ['example1_input', 'example1_output', 'example2_input', 'example2_output', 'actual_input'],
+    },
+    'structured-output': {
+        name: 'structured-output',
+        description: 'Force structured JSON output',
+        template: `{task}
+
+Respond ONLY with a JSON object in this exact format (no markdown, no explanation):
+{schema}`,
+        variables: ['task', 'schema'],
+    },
+    'critique-and-revise': {
+        name: 'critique-and-revise',
+        description: 'Self-critique and improve an answer',
+        template: `{task}
+
+First, provide your initial answer.
+Then, critique it: what's missing, what could be wrong, what could be clearer?
+Finally, provide a revised, improved answer incorporating your critique.
+
+Initial answer:
+[your first attempt]
+
+Critique:
+[what you'd improve]
+
+Revised answer:
+[your improved answer]`,
+        variables: ['task'],
+    },
+    'least-to-most': {
+        name: 'least-to-most',
+        description: 'Break down into simpler sub-problems first',
+        template: `To solve: {problem}
+
+First, identify the simpler sub-problems that lead to the solution.
+Solve each sub-problem in order, using each answer to help with the next.
+
+Sub-problems:
+1. [simplest piece]
+2. [next piece]
+...
+
+Now solve each:`,
+        variables: ['problem'],
+    },
+    'react-agent': {
+        name: 'react-agent',
+        description: 'ReAct (Reason + Act) prompting pattern',
+        template: `Task: {task}
+
+Use this format:
+Thought: [your reasoning about the current situation]
+Action: [action to take from: {available_actions}]
+Observation: [result of the action]
+... (repeat until done)
+Thought: I now have enough information to answer
+Answer: [final answer]`,
+        variables: ['task', 'available_actions'],
+    },
+    'socratic': {
+        name: 'socratic',
+        description: 'Lead the user to the answer through questions',
+        template: `Instead of directly answering "{question}", help the user discover the answer themselves.
+
+Ask 2-3 probing questions that guide them toward understanding.
+After they respond, lead them closer to the answer.
+Only reveal the full answer if they are completely stuck.`,
+        variables: ['question'],
+    },
+};
+
+class PromptEngineer {
+    constructor() {
+        this._library = this._loadLibrary();
+    }
+
+    _loadLibrary() {
+        try { if (fs.existsSync(LIBRARY_FILE)) return JSON.parse(fs.readFileSync(LIBRARY_FILE, 'utf-8')); } catch { }
+        return {};
+    }
+    _saveLibrary() { fs.writeFileSync(LIBRARY_FILE, JSON.stringify(this._library, null, 2)); }
+
+    /**
+     * Analyse a prompt and identify its weaknesses
+     */
+    async analyse(prompt, opts = {}) {
+        logger.info(`[PromptEngineer] Analysing prompt (${prompt.length} chars)`);
+        const response = await llm.chat({
+            model: llm.model('smart'), max_tokens: 800,
+            system: `You are a prompt engineering expert. Analyse prompts with precision and suggest concrete improvements.`,
+            messages: [{ role: 'user', content: `Analyse this prompt and score it 1-10 on each dimension:\n\n---\n${prompt}\n---\n\nReturn JSON:\n{"scores":{"clarity":0,"specificity":0,"context":0,"output_format":0,"role_framing":0,"examples":0},"weaknesses":["..."],"strengths":["..."],"overall_score":0}` }],
+        });
+        costTracker.record({ model: llm.model('smart'), inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens, sessionId: opts.sessionId || 'prompt-engineer', queryType: 'prompt-analyse' });
+        try { return JSON.parse(response.content[0].text.replace(/```json\n?|\n?```/g, '').trim()); }
+        catch { return { raw: response.content[0].text }; }
+    }
+
+    /**
+     * Automatically improve a prompt
+     */
+    async improve(prompt, opts = {}) {
+        const { goal = '', style = 'concise' } = opts;
+        logger.info(`[PromptEngineer] Improving prompt`);
+
+        const analysis = await this.analyse(prompt, opts);
+
+        const response = await llm.chat({
+            model: llm.model('smart'), max_tokens: 1200,
+            system: `You are an expert prompt engineer. Rewrite prompts to be clearer, more specific, and more effective.`,
+            messages: [{ role: 'user', content: `Original prompt:\n---\n${prompt}\n---\n\nWeaknesses identified: ${JSON.stringify(analysis.weaknesses || [])}\n\n${goal ? `Goal: ${goal}` : ''}\nStyle: ${style}\n\nRewrite the prompt to fix all weaknesses. Return:\n{"improved_prompt":"...","changes_made":["..."],"expected_improvement":"..."}` }],
+        });
+        costTracker.record({ model: llm.model('smart'), inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens, sessionId: opts.sessionId || 'prompt-engineer', queryType: 'prompt-improve' });
+
+        try {
+            const result = JSON.parse(response.content[0].text.replace(/```json\n?|\n?```/g, '').trim());
+            return { ...result, original: prompt, analysis };
+        } catch {
+            return { improved_prompt: response.content[0].text, original: prompt };
+        }
+    }
+
+    /**
+     * Generate a prompt from a task description
+     */
+    async generate(taskDescription, opts = {}) {
+        const { type = 'instruction', model = 'smart', includeExamples = false } = opts;
+        logger.info(`[PromptEngineer] Generating prompt for: ${taskDescription.slice(0, 60)}`);
+
+        const response = await llm.chat({
+            model: llm.model('smart'), max_tokens: 1000,
+            messages: [{ role: 'user', content: `Generate an optimal ${type} prompt for this task:\n"${taskDescription}"\n\nTarget model: ${model}\nInclude examples: ${includeExamples}\n\nReturn:\n{"system_prompt":"...","user_prompt_template":"...","key_techniques":["..."],"variables":["..."]}` }],
+        });
+        costTracker.record({ model: llm.model('smart'), inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens, sessionId: opts.sessionId || 'prompt-engineer', queryType: 'prompt-generate' });
+        try { return JSON.parse(response.content[0].text.replace(/```json\n?|\n?```/g, '').trim()); }
+        catch { return { user_prompt_template: response.content[0].text }; }
+    }
+
+    /**
+     * A/B test two prompts against a test case
+     */
+    async abTest(promptA, promptB, testInput, opts = {}) {
+        logger.info(`[PromptEngineer] A/B testing two prompts`);
+
+        const [resA, resB] = await Promise.all([
+            llm.chat({ model: llm.model('fast'), max_tokens: 500, messages: [{ role: 'user', content: `${promptA}\n\nInput: ${testInput}` }] }),
+            llm.chat({ model: llm.model('fast'), max_tokens: 500, messages: [{ role: 'user', content: `${promptB}\n\nInput: ${testInput}` }] }),
+        ]);
+
+        const outputA = resA.content[0].text;
+        const outputB = resB.content[0].text;
+
+        // Judge which is better
+        const judge = await llm.chat({
+            model: llm.model('fast'), max_tokens: 300,
+            messages: [{ role: 'user', content: `Compare these two AI outputs for the task: "${testInput}"\n\nOutput A:\n${outputA}\n\nOutput B:\n${outputB}\n\nWhich is better and why? Return JSON:\n{"winner":"A|B|tie","score_a":0,"score_b":0,"reasoning":"...","key_difference":"..."}` }],
+        });
+
+        for (const r of [resA, resB, judge]) {
+            costTracker.record({ model: llm.model('fast'), inputTokens: r.usage.input_tokens, outputTokens: r.usage.output_tokens, sessionId: opts.sessionId || 'prompt-engineer', queryType: 'prompt-abtest' });
+        }
+
+        try {
+            const verdict = JSON.parse(judge.content[0].text.replace(/```json\n?|\n?```/g, '').trim());
+            return { promptA, promptB, testInput, outputA, outputB, verdict };
+        } catch {
+            return { promptA, promptB, outputA, outputB, verdict: { raw: judge.content[0].text } };
+        }
+    }
+
+    /**
+     * Apply a prompt template with variable substitution
+     */
+    applyTemplate(templateName, variables = {}) {
+        const t = this._library[templateName] || BUILTIN_TEMPLATES[templateName];
+        if (!t) throw new Error(`Template not found: ${templateName}. Available: ${this.listTemplates().map(t => t.name).join(', ')}`);
+        let result = t.template;
+        for (const [k, v] of Object.entries(variables)) {
+            result = result.replace(new RegExp(`\\{${k}\\}`, 'g'), v);
+        }
+        const missing = (result.match(/\{(\w+)\}/g) || []);
+        if (missing.length) logger.warn(`[PromptEngineer] Unfilled variables: ${missing.join(', ')}`);
+        return result;
+    }
+
+    /**
+     * Inject chain-of-thought reasoning into any prompt
+     */
+    injectCoT(prompt, style = 'standard') {
+        const injections = {
+            standard: `\n\nThink through this carefully, step by step, before giving your final answer.`,
+            detailed: `\n\nBefore answering:\n1. Understand what's being asked\n2. Identify relevant information\n3. Consider edge cases\n4. Work through the solution\n5. Verify your answer\n\nNow answer:`,
+            socratic: `\n\nAsk yourself: What do I know? What don't I know? What's the simplest path? Then answer:`,
+            zero_shot: `\n\nLet's think about this step by step:`,
+        };
+        return prompt + (injections[style] || injections.standard);
+    }
+
+    /** Save a custom template to the library */
+    saveTemplate(name, description, template, variables = []) {
+        if (BUILTIN_TEMPLATES[name]) throw new Error(`Cannot override built-in template: ${name}`);
+        this._library[name] = { name, description, template, variables, custom: true, createdAt: new Date().toISOString() };
+        this._saveLibrary();
+        return this._library[name];
+    }
+
+    deleteTemplate(name) {
+        if (BUILTIN_TEMPLATES[name]) throw new Error('Cannot delete built-in templates');
+        if (!this._library[name]) throw new Error(`Template not found: ${name}`);
+        delete this._library[name]; this._saveLibrary(); return true;
+    }
+
+    listTemplates() {
+        return [
+            ...Object.values(BUILTIN_TEMPLATES).map(t => ({ ...t, builtIn: true })),
+            ...Object.values(this._library).map(t => ({ ...t, builtIn: false })),
+        ];
+    }
+
+    getTemplate(name) {
+        return this._library[name] || BUILTIN_TEMPLATES[name] || null;
+    }
+}
+
+module.exports = new PromptEngineer();