sofia-cli 0.1.1

package/dist/src/develop/mcpContextEnricher.js

@@ -0,0 +1,195 @@
+import { isWebSearchConfigured } from '../mcp/webSearch.js';
+// ── Azure keyword detection ───────────────────────────────────────────────────
+const AZURE_KEYWORDS = [
+    'azure',
+    'cosmos db',
+    'cosmosdb',
+    'blob storage',
+    'service bus',
+    'event hub',
+    'app service',
+    'azure sql',
+    'key vault',
+    'azure functions',
+    'azure openai',
+];
+function mentionsAzure(text) {
+    const lower = text.toLowerCase();
+    return AZURE_KEYWORDS.some((kw) => lower.includes(kw));
+}
+// ── McpContextEnricher ────────────────────────────────────────────────────────
+/**
+ * Enriches LLM iteration prompts with context from MCP services.
+ *
+ * Each method degrades gracefully — returns undefined when service
+ * is unavailable rather than throwing.
+ */
+export class McpContextEnricher {
+    /** @internal Exposed for RalphLoop integration */
+    mcpManager;
+    constructor(mcpManager) {
+        this.mcpManager = mcpManager;
+    }
+    /**
+     * Enrich the iteration context with MCP-sourced information.
+     *
+     * Queries are conditional on:
+     * 1. Context7: available AND dependencies listed in plan
+     * 2. Azure MCP: available AND plan references Azure services
+     * 3. web.search: configured AND stuckIterations >= 2
+     */
+    async enrich(options) {
+        const { dependencies = [], architectureNotes = '', stuckIterations = 0 } = options;
+        const parts = [];
+        let libraryDocs;
+        let azureGuidance;
+        let webSearchResults;
+        // Context7 + Azure MCP: run concurrently via Promise.allSettled()
+        const concurrent = [];
+        if (this.mcpManager.isAvailable('context7') && dependencies.length > 0) {
+            concurrent.push(this.queryContext7(dependencies).then((result) => {
+                libraryDocs = result;
+            }));
+        }
+        if (this.mcpManager.isAvailable('azure') && mentionsAzure(architectureNotes)) {
+            concurrent.push(this.queryAzureMcp(architectureNotes).then((result) => {
+                azureGuidance = result;
+            }));
+        }
+        await Promise.allSettled(concurrent);
+        if (libraryDocs)
+            parts.push(`### Library Documentation (Context7)\n\n${libraryDocs}`);
+        if (azureGuidance)
+            parts.push(`### Azure Architecture Guidance\n\n${azureGuidance}`);
+        // web.search: when stuck for 2+ iterations
+        if (isWebSearchConfigured() && stuckIterations >= 2 && options.failingTests?.length) {
+            webSearchResults = await this.queryWebSearch(options.failingTests);
+            if (webSearchResults)
+                parts.push(`### Web Search Results\n\n${webSearchResults}`);
+        }
+        return {
+            libraryDocs,
+            azureGuidance,
+            webSearchResults,
+            combined: parts.join('\n\n'),
+        };
+    }
+    /**
+     * Query Context7 for library documentation.
+     *
+     * Calls `mcpManager.callTool('context7', 'resolve-library-id', ...)` to
+     * resolve each dependency, then `query-docs` for the resolved library.
+     * Degrades gracefully when the service is unavailable or errors.
+     */
+    async queryContext7(dependencies) {
+        if (!this.mcpManager.isAvailable('context7'))
+            return undefined;
+        try {
+            const docs = [];
+            for (const dep of dependencies.slice(0, 5)) {
+                // Filter out type-only and well-known packages that don't need lookup
+                if (dep.startsWith('@types/') || dep === 'typescript' || dep === 'vitest') {
+                    continue;
+                }
+                try {
+                    // Step 1: Resolve library ID
+                    const resolved = await this.mcpManager.callTool('context7', 'resolve-library-id', {
+                        libraryName: dep,
+                    }, { timeoutMs: 30_000 });
+                    const libraryId = resolved.libraryId ?? resolved.id;
+                    if (!libraryId) {
+                        docs.push(`- **${dep}**: See https://www.npmjs.com/package/${dep} for API documentation`);
+                        continue;
+                    }
+                    // Step 2: Query docs with the resolved ID
+                    const docResult = await this.mcpManager.callTool('context7', 'query-docs', {
+                        libraryId,
+                        topic: dep,
+                    }, { timeoutMs: 30_000 });
+                    const content = docResult.content ?? docResult.text;
+                    if (content) {
+                        docs.push(`- **${dep}**:\n${content}`);
+                    }
+                    else {
+                        docs.push(`- **${dep}**: See https://www.npmjs.com/package/${dep} for API documentation`);
+                    }
+                }
+                catch {
+                    // Individual dep failure — fallback link
+                    docs.push(`- **${dep}**: See https://www.npmjs.com/package/${dep} for API documentation`);
+                }
+            }
+            return docs.length > 0 ? docs.join('\n') : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Query Azure MCP for architecture guidance.
+     *
+     * Calls `mcpManager.callTool('azure', 'documentation', ...)` with detected
+     * Azure keywords. Degrades gracefully when Azure MCP is unavailable.
+     */
+    async queryAzureMcp(architectureNotes) {
+        if (!this.mcpManager.isAvailable('azure'))
+            return undefined;
+        try {
+            const detected = AZURE_KEYWORDS.filter((kw) => architectureNotes.toLowerCase().includes(kw));
+            if (detected.length === 0)
+                return undefined;
+            try {
+                const response = await this.mcpManager.callTool('azure', 'documentation', {
+                    query: `Best practices for ${detected.join(', ')}`,
+                }, { timeoutMs: 30_000 });
+                const content = response.content ?? response.text;
+                if (content) {
+                    return content;
+                }
+            }
+            catch {
+                // MCP call failed — fall back to static guidance
+            }
+            return [
+                `Detected Azure services: ${detected.join(', ')}`,
+                'Use the @azure/identity DefaultAzureCredential for authentication.',
+                'Prefer connection strings from environment variables (never hardcode).',
+            ].join('\n');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Query web search for solutions to failing tests.
+     *
+     * Only called when stuckIterations >= 2 to avoid unnecessary API calls.
+     * Uses `mcpManager.callTool` to search for error messages.
+     */
+    async queryWebSearch(failingTests) {
+        if (!isWebSearchConfigured())
+            return undefined;
+        try {
+            const query = failingTests.slice(0, 3).join('; ');
+            // Attempt real web search via MCP if available
+            if (this.mcpManager.isAvailable('websearch')) {
+                try {
+                    const response = await this.mcpManager.callTool('websearch', 'search', {
+                        query: `how to fix: ${query}`,
+                    }, { timeoutMs: 30_000 });
+                    const content = response.content ?? response.text;
+                    if (content) {
+                        return content;
+                    }
+                }
+                catch {
+                    // Web search MCP unavailable — fall through to static message
+                }
+            }
+            return `Web search for: "${query}" — no results available in this environment.`;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}