@benchcubed/today-cli 1.0.0

package/dist/lambda/knowledge-ai.js

@@ -0,0 +1,849 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+const client_cognito_identity_provider_1 = require("@aws-sdk/client-cognito-identity-provider");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+// Initialize AWS clients
+const dynamoClient = new client_dynamodb_1.DynamoDBClient({});
+const bedrockClient = new client_bedrock_runtime_1.BedrockRuntimeClient({});
+const s3Client = new client_s3_1.S3Client({});
+const cognitoClient = new client_cognito_identity_provider_1.CognitoIdentityProviderClient({});
+const userNameCache = new Map();
+const EMBEDDING_MODEL = 'amazon.titan-embed-text-v2:0';
+const RELEVANCE_THRESHOLD = 0.3;
+const MAX_SEARCH_RESULTS = 10;
+const MIN_CONFIDENCE = 0.1;
+const MAX_CONFIDENCE = 0.95;
+const RECENCY_DECAY_DAYS = 90;
+const MILLISECONDS_PER_DAY = 1000 * 60 * 60 * 24; // Milliseconds in a day
+// Scoring weights for hybrid search (intentBoost is applied as additional bonus)
+const SCORE_WEIGHTS = {
+    semantic: 0.5, // 50% weight for semantic similarity
+    keyword: 0.3, // 30% weight for keyword matching
+    topic: 0.1, // 10% weight for topic overlap
+    recency: 0.1, // 10% weight for recency (total = 1.0)
+    intentBoost: 0.1 // Additional boost applied when intent matches (not part of base scoring)
+};
+// Intent-based content matching keywords
+const INTENT_KEYWORDS = {
+    'debug': 'error',
+    'how-to': 'step',
+    'configure': 'config'
+};
+// Helper function to decode JWT token (without verification for simplicity)
+function decodeJWT(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        console.error('Failed to decode JWT:', error);
+        return null;
+    }
+}
+// Fetch user name from Cognito with caching
+async function getUserName(userId) {
+    // Check cache first
+    if (userNameCache.has(userId)) {
+        return userNameCache.get(userId);
+    }
+    try {
+        const response = await cognitoClient.send(new client_cognito_identity_provider_1.AdminGetUserCommand({
+            UserPoolId: process.env.USER_POOL_ID,
+            Username: userId,
+        }));
+        // Use the username from Cognito
+        const userName = response.Username || userId;
+        userNameCache.set(userId, userName);
+        return userName;
+    }
+    catch (error) {
+        console.warn(`Failed to fetch user name for ${userId}:`, error);
+        userNameCache.set(userId, userId);
+        return userId;
+    }
+}
+// Enrich entries with usernames
+async function enrichEntriesWithUsernames(entries) {
+    return Promise.all(entries.map(async (entry) => {
+        const username = await getUserName(entry.authorId);
+        return {
+            ...entry,
+            username
+        };
+    }));
+}
+// Extract user info from Authorization header
+function getUserFromAuth(event) {
+    const authHeader = event.headers?.Authorization || event.headers?.authorization;
+    if (!authHeader)
+        return null;
+    const token = authHeader.replace('Bearer ', '');
+    const decoded = decodeJWT(token);
+    if (!decoded || !decoded.sub)
+        return null;
+    return {
+        userId: decoded.sub,
+        teamId: decoded['custom:team_id'] || 'default'
+    };
+}
+// ========== VECTOR EMBEDDING HELPER FUNCTIONS ==========
+/**
+ * Generate vector embedding using Amazon Bedrock Titan Embeddings
+ * @param text - Text to generate embedding for
+ * @returns Vector embedding (1024 dimensions for Titan v2)
+ */
+async function generateEmbedding(text) {
+    try {
+        const preprocessedText = text
+            .trim()
+            .replace(/\s+/g, ' ')
+            .substring(0, 8000); // Limit to 8000 chars for cost optimization
+        const response = await bedrockClient.send(new client_bedrock_runtime_1.InvokeModelCommand({
+            modelId: EMBEDDING_MODEL,
+            contentType: 'application/json',
+            body: JSON.stringify({
+                inputText: preprocessedText,
+                dimensions: 1024 // Specify output dimensions for Titan v2
+            }),
+        }));
+        const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+        // Validate response has embedding
+        if (!responseBody.embedding || !Array.isArray(responseBody.embedding)) {
+            console.warn('Invalid embedding response format:', responseBody);
+            return [];
+        }
+        return responseBody.embedding;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.warn('Failed to generate embedding:', errorMessage, error);
+        return []; // Return empty array on failure
+    }
+}
+/**
+ * Calculate cosine similarity between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Similarity score (0 to 1)
+ */
+function cosineSimilarity(a, b) {
+    // Validate inputs
+    if (!a || !b || !Array.isArray(a) || !Array.isArray(b)) {
+        return 0;
+    }
+    if (a.length !== b.length || a.length === 0) {
+        return 0;
+    }
+    const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
+    const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
+    const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
+    if (magnitudeA === 0 || magnitudeB === 0) {
+        return 0;
+    }
+    return dotProduct / (magnitudeA * magnitudeB);
+}
+// ========== END HELPER FUNCTIONS ==========
+/**
+ * Enhance user query using Claude Haiku to extract intent and expand terms
+ * @param question - Original user question
+ * @returns Enhanced query metadata
+ */
+async function enhanceQuery(question) {
+    try {
+        const prompt = `Analyze this developer question and extract structured information:
+
+Question: "${question}"
+
+Provide a JSON response with:
+1. intent: Primary intent (one of: "how-to", "debug", "explain", "find-example", "configure")
+2. keywords: 3-5 key technical terms
+3. expandedTerms: 3-5 related or synonym terms
+4. topics: 2-4 technology topics
+
+Example format:
+{
+  "intent": "debug",
+  "keywords": ["authentication", "api", "errors"],
+  "expandedTerms": ["auth", "authorization", "access-denied", "401", "403"],
+  "topics": ["api-gateway", "lambda", "security"]
+}
+
+Respond ONLY with valid JSON, no other text.`;
+        const response = await bedrockClient.send(new client_bedrock_runtime_1.InvokeModelCommand({
+            modelId: 'anthropic.claude-3-haiku-20240307-v1:0',
+            contentType: 'application/json',
+            body: JSON.stringify({
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: 300,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            }),
+        }));
+        const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+        // Validate response structure
+        if (!responseBody.content || !Array.isArray(responseBody.content) || responseBody.content.length === 0) {
+            console.warn('Invalid query enhancement response format:', responseBody);
+            const words = question.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+            return {
+                intent: 'general',
+                keywords: words.slice(0, 5),
+                expandedTerms: [],
+                topics: [],
+            };
+        }
+        // Parse AI response with error handling
+        let analysis;
+        try {
+            analysis = JSON.parse(responseBody.content[0].text);
+        }
+        catch (parseError) {
+            console.warn('Failed to parse AI query enhancement JSON:', parseError);
+            const words = question.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+            return {
+                intent: 'general',
+                keywords: words.slice(0, 5),
+                expandedTerms: [],
+                topics: [],
+            };
+        }
+        return {
+            intent: analysis.intent || 'general',
+            keywords: analysis.keywords || [],
+            expandedTerms: analysis.expandedTerms || [],
+            topics: analysis.topics || [],
+        };
+    }
+    catch (error) {
+        console.warn('Query enhancement failed, using fallback:', error);
+        // Fallback to simple keyword extraction
+        const words = question.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+        return {
+            intent: 'general',
+            keywords: words.slice(0, 5),
+            expandedTerms: [],
+            topics: [],
+        };
+    }
+}
+const handler = async (event) => {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+        'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
+    };
+    try {
+        const { httpMethod, path, body, queryStringParameters } = event;
+        // Extract user info from Authorization header
+        const userInfo = getUserFromAuth(event);
+        if (!userInfo) {
+            return {
+                statusCode: 401,
+                headers,
+                body: JSON.stringify({ error: 'Unauthorized' }),
+            };
+        }
+        const { userId, teamId } = userInfo;
+        switch (httpMethod) {
+            case 'POST':
+                if (path.endsWith('/knowledge')) {
+                    return await captureKnowledge(JSON.parse(body || '{}'), userId, teamId);
+                }
+                break;
+            case 'GET':
+                if (path.endsWith('/knowledge')) {
+                    const query = queryStringParameters?.q;
+                    if (query) {
+                        return await processQuestion(query, userId, teamId);
+                    }
+                    else {
+                        // List all knowledge entries
+                        return await listKnowledgeEntries(userId, teamId);
+                    }
+                }
+                if (path.endsWith('/experts')) {
+                    const topic = queryStringParameters?.topic || '';
+                    return await findExperts(topic, userId, teamId);
+                }
+                break;
+            default:
+                return {
+                    statusCode: 405,
+                    headers,
+                    body: JSON.stringify({ error: 'Method not allowed' }),
+                };
+        }
+        return {
+            statusCode: 404,
+            headers,
+            body: JSON.stringify({ error: 'Not found' }),
+        };
+    }
+    catch (error) {
+        console.error('Lambda error:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({
+                error: 'Internal server error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            }),
+        };
+    }
+};
+exports.handler = handler;
+/**
+ * Check entry content against default custom topics
+ * @param content - Entry content to check
+ * @param teamId - Team ID
+ * @returns Array of matching custom topic IDs
+ */
+async function checkAgainstDefaultTopics(content, teamId) {
+    try {
+        // Get all default custom topics for the team
+        const response = await dynamoClient.send(new client_dynamodb_1.QueryCommand({
+            TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+            KeyConditionExpression: 'team_id = :teamId AND begins_with(relationship_id, :prefix)',
+            ExpressionAttributeValues: {
+                ':teamId': { S: teamId },
+                ':prefix': { S: 'custom-topic-' },
+            },
+        }));
+        if (!response.Items || response.Items.length === 0) {
+            return [];
+        }
+        const matchingTopics = [];
+        const contentLower = content.toLowerCase();
+        for (const item of response.Items) {
+            const unmarshalled = (0, util_dynamodb_1.unmarshall)(item);
+            // Only check default topics
+            if (unmarshalled.is_default !== true) {
+                continue;
+            }
+            const topicData = JSON.parse(unmarshalled.topic_data || '{}');
+            const topicName = topicData.name || '';
+            const topicDescription = topicData.description || '';
+            // Improved keyword matching with word boundary checks
+            const matchesName = topicName && new RegExp(`\\b${topicName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(content);
+            const matchesDescription = topicDescription && new RegExp(`\\b${topicDescription.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(content);
+            if (matchesName || matchesDescription) {
+                matchingTopics.push(topicData.id);
+            }
+        }
+        return matchingTopics;
+    }
+    catch (error) {
+        console.error('Error checking against default topics:', error);
+        return [];
+    }
+}
+async function captureKnowledge(entry, userId, teamId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+    };
+    try {
+        // Generate unique ID
+        const entryId = `${teamId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Parallelize AI enhancement, embedding generation, and default topic checking
+        console.log('Generating AI analysis, vector embedding, and checking default topics in parallel...');
+        const [enhancedEntry, embedding, matchingCustomTopics] = await Promise.all([
+            enhanceWithAI(entry.content || '', userId, teamId),
+            generateEmbedding(entry.content || ''),
+            checkAgainstDefaultTopics(entry.content || '', teamId)
+        ]);
+        console.log(`AI analysis complete. Embedding generated: ${embedding.length} dimensions. Matched ${matchingCustomTopics.length} default topics.`);
+        const learningEntry = {
+            id: entryId,
+            content: entry.content || '',
+            authorId: userId,
+            teamId,
+            createdAt: new Date().toISOString(),
+            aiTopics: enhancedEntry.extractedTopics,
+            customTopics: matchingCustomTopics, // Add matched custom topics
+            expertiseLevel: enhancedEntry.expertiseLevel,
+            impactScore: enhancedEntry.potentialImpact,
+            helpfulnessRating: 0,
+            timeSavedMinutes: 0,
+            viewCount: 0,
+            shareCount: 0,
+            questionsAnswered: 0,
+            onboardingRelevance: enhancedEntry.onboardingRelevance,
+            embedding, // Store embedding for semantic search
+        };
+        // Store in DynamoDB knowledge graph
+        const putItemParams = {
+            TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+            Item: {
+                team_id: { S: teamId },
+                relationship_id: { S: `entry-${entryId}` },
+                user_id: { S: userId },
+                entry_data: { S: JSON.stringify(learningEntry) },
+                created_at: { S: learningEntry.createdAt },
+                topics: { SS: learningEntry.aiTopics },
+                author_id: { S: userId },
+                expertise_score: { N: learningEntry.impactScore.toString() },
+            },
+        };
+        // Store embedding in S3 and save reference in DynamoDB
+        if (embedding && embedding.length > 0 && putItemParams.Item) {
+            // Validate embedding values are finite numbers
+            const validEmbedding = embedding.every(v => Number.isFinite(v));
+            if (validEmbedding) {
+                try {
+                    const embeddingKey = `embeddings/${teamId}/${entryId}.json`;
+                    const embeddingsBucket = process.env.EMBEDDINGS_BUCKET || `${process.env.PROJECT_NAME || 'today'}-embeddings`;
+                    // Store embedding in S3 as compact JSON
+                    await s3Client.send(new client_s3_1.PutObjectCommand({
+                        Bucket: embeddingsBucket,
+                        Key: embeddingKey,
+                        Body: JSON.stringify(embedding),
+                        ContentType: 'application/json',
+                        ServerSideEncryption: 'AES256',
+                        Metadata: {
+                            entryId,
+                            teamId,
+                            dimensions: embedding.length.toString(),
+                            createdAt: learningEntry.createdAt,
+                        }
+                    }));
+                    // Store only the S3 key in DynamoDB (much smaller than 1024 numbers)
+                    putItemParams.Item.embedding_s3_key = { S: embeddingKey };
+                    console.log(`Embedding stored in S3: s3://${embeddingsBucket}/${embeddingKey}`);
+                }
+                catch (s3Error) {
+                    console.error('Failed to store embedding in S3:', s3Error);
+                    // Continue without embedding if S3 fails
+                }
+            }
+            else {
+                console.warn('Embedding contains invalid values (NaN or Infinity), skipping storage');
+            }
+        }
+        await dynamoClient.send(new client_dynamodb_1.PutItemCommand(putItemParams));
+        // Create relationships for AI-extracted topics
+        for (const topic of learningEntry.aiTopics) {
+            await dynamoClient.send(new client_dynamodb_1.PutItemCommand({
+                TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+                Item: {
+                    team_id: { S: teamId },
+                    relationship_id: { S: `topic-${topic}-${entryId}` },
+                    topic: { S: topic },
+                    entry_id: { S: entryId },
+                    author_id: { S: userId },
+                    expertise_score: { N: learningEntry.impactScore.toString() },
+                    created_at: { S: learningEntry.createdAt },
+                },
+            }));
+        }
+        // Create relationships for custom topics
+        for (const customTopicId of matchingCustomTopics) {
+            await dynamoClient.send(new client_dynamodb_1.PutItemCommand({
+                TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+                Item: {
+                    team_id: { S: teamId },
+                    relationship_id: { S: `custom-topic-entry-${customTopicId}-${entryId}` },
+                    topic_id: { S: customTopicId },
+                    entry_id: { S: entryId },
+                    created_at: { S: learningEntry.createdAt },
+                },
+            }));
+        }
+        return {
+            statusCode: 201,
+            headers,
+            body: JSON.stringify({
+                success: true,
+                entry: learningEntry,
+                message: 'Knowledge entry created successfully',
+            }),
+        };
+    }
+    catch (error) {
+        console.error('Error capturing knowledge:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({
+                error: 'Failed to capture knowledge',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }),
+        };
+    }
+}
+async function listKnowledgeEntries(userId, teamId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+    };
+    try {
+        const queryParams = {
+            TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+            IndexName: 'team-user-index',
+            KeyConditionExpression: 'team_id = :teamId AND user_id = :userId',
+            FilterExpression: 'begins_with(relationship_id, :prefix)',
+            ExpressionAttributeValues: {
+                ':teamId': { S: teamId },
+                ':userId': { S: userId },
+                ':prefix': { S: 'entry-' },
+            },
+        };
+        const result = await dynamoClient.send(new client_dynamodb_1.QueryCommand(queryParams));
+        const entries = (result.Items || []).map((item) => {
+            // Parse entry_data JSON
+            const entryData = item.entry_data?.S ? JSON.parse(item.entry_data.S) : {};
+            return {
+                ...entryData,
+                // Include S3 key for lazy-loading embeddings (instead of embedding_vector)
+                embedding_s3_key: item.embedding_s3_key?.S,
+                // Keep backward compatibility with old entries that have embedding_vector
+                embedding_vector: item.embedding_vector,
+            };
+        });
+        // Enrich entries with usernames from Cognito
+        const enrichedEntries = await enrichEntriesWithUsernames(entries);
+        return {
+            statusCode: 200,
+            headers,
+            body: JSON.stringify({
+                success: true,
+                data: {
+                    entries: enrichedEntries,
+                    total: enrichedEntries.length,
+                },
+            }),
+        };
+    }
+    catch (error) {
+        console.error('Error listing knowledge entries:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({
+                error: 'Failed to list knowledge entries',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }),
+        };
+    }
+}
+async function processQuestion(question, _userId, _teamId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+    };
+    try {
+        console.log(`Processing question: "${question}" for user: ${_userId}, team: ${_teamId}`);
+        // Query knowledge entries from team
+        const queryParams = {
+            TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+            KeyConditionExpression: 'team_id = :teamId AND begins_with(relationship_id, :prefix)',
+            ExpressionAttributeValues: {
+                ':teamId': { S: _teamId },
+                ':prefix': { S: 'entry-' },
+            },
+            Limit: 50, // Limit for cost optimization
+        };
+        console.log('DynamoDB Query params:', JSON.stringify(queryParams, null, 2));
+        const queryResult = await dynamoClient.send(new client_dynamodb_1.QueryCommand(queryParams));
+        console.log(`DynamoDB Query result: ${queryResult.Items?.length || 0} items found`);
+        const entries = [];
+        if (queryResult.Items) {
+            for (const item of queryResult.Items) {
+                console.log('Processing item:', JSON.stringify(item, null, 2));
+                if (item.entry_data?.S) {
+                    try {
+                        entries.push(JSON.parse(item.entry_data.S));
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse entry data:', e);
+                    }
+                }
+            }
+        }
+        console.log(`Parsed ${entries.length} entries successfully`);
+        // Enrich entries with usernames from Cognito
+        const enrichedEntries = await enrichEntriesWithUsernames(entries);
+        // If no question provided, return all entries (for stats/impact commands)
+        if (!question || question.trim() === '') {
+            console.log('No question provided, returning all entries');
+            return {
+                statusCode: 200,
+                headers,
+                body: JSON.stringify({
+                    success: true,
+                    entries: enrichedEntries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()),
+                }),
+            };
+        }
+        // Use AI to analyze question and match entries
+        const answer = await analyzeQuestionWithAI(question, enrichedEntries, _teamId);
+        // Enrich answer's relevant entries with usernames (in case they weren't already enriched)
+        if (answer.relevantEntries) {
+            answer.relevantEntries = await enrichEntriesWithUsernames(answer.relevantEntries);
+        }
+        return {
+            statusCode: 200,
+            headers,
+            body: JSON.stringify({
+                success: true,
+                answer,
+                totalEntries: enrichedEntries.length,
+            }),
+        };
+    }
+    catch (error) {
+        console.error('Error processing question:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({
+                error: 'Failed to process question',
+                message: error instanceof Error ? error.message : 'Unknown error',
+                details: error instanceof Error ? error.stack : 'No stack trace',
+            }),
+        };
+    }
+}
+async function findExperts(topic, _userId, _teamId) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+    };
+    try {
+        // Query by topic using GSI
+        const queryResult = await dynamoClient.send(new client_dynamodb_1.QueryCommand({
+            TableName: process.env.KNOWLEDGE_GRAPH_TABLE,
+            IndexName: 'topic-expertise-index',
+            KeyConditionExpression: 'topic = :topic',
+            ExpressionAttributeValues: {
+                ':topic': { S: topic },
+            },
+            ScanIndexForward: false, // Sort by expertise_score descending
+            Limit: 10,
+        }));
+        const experts = [];
+        const expertMap = new Map();
+        if (queryResult.Items) {
+            for (const item of queryResult.Items) {
+                const authorId = item.author_id?.S;
+                const entryId = item.entry_id?.S;
+                const score = parseFloat(item.expertise_score?.N || '0');
+                if (authorId && entryId) {
+                    if (!expertMap.has(authorId)) {
+                        expertMap.set(authorId, { score: 0, entries: [] });
+                    }
+                    const expert = expertMap.get(authorId);
+                    expert.score += score;
+                    expert.entries.push(entryId);
+                }
+            }
+        }
+        // Convert to expert matches - fetch actual usernames from Cognito
+        for (const [authorId, data] of expertMap.entries()) {
+            const userName = await getUserName(authorId);
+            experts.push({
+                userId: authorId,
+                name: userName,
+                relevantEntries: data.entries,
+                expertiseScore: data.score,
+                lastActive: new Date().toISOString(), // In real app, track actual activity
+            });
+        }
+        // Sort by expertise score
+        experts.sort((a, b) => b.expertiseScore - a.expertiseScore);
+        return {
+            statusCode: 200,
+            headers,
+            body: JSON.stringify({
+                success: true,
+                experts: experts.slice(0, 5), // Top 5 experts
+                topic,
+            }),
+        };
+    }
+    catch (error) {
+        console.error('Error finding experts:', error);
+        return {
+            statusCode: 500,
+            headers,
+            body: JSON.stringify({
+                error: 'Failed to find experts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }),
+        };
+    }
+}
+async function enhanceWithAI(content, _userId, _teamId) {
+    try {
+        const prompt = `Analyze this developer learning entry and extract:
+1. Key topics/technologies (max 5, lowercase, no spaces)
+2. Expertise level (beginner/intermediate/expert)
+3. Potential impact score (1-10)
+4. Onboarding relevance (true/false)
+
+Content: "${content}"
+
+Respond in JSON format:
+{
+  "topics": ["topic1", "topic2"],
+  "expertiseLevel": "intermediate",
+  "impactScore": 7,
+  "onboardingRelevance": true
+}`;
+        const response = await bedrockClient.send(new client_bedrock_runtime_1.InvokeModelCommand({
+            modelId: 'anthropic.claude-3-haiku-20240307-v1:0',
+            contentType: 'application/json',
+            body: JSON.stringify({
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: 200,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            }),
+        }));
+        const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+        const aiResponse = JSON.parse(responseBody.content[0].text);
+        return {
+            extractedTopics: aiResponse.topics || ['general'],
+            expertiseLevel: aiResponse.expertiseLevel || 'intermediate',
+            potentialImpact: aiResponse.impactScore || 5,
+            onboardingRelevance: aiResponse.onboardingRelevance || false,
+        };
+    }
+    catch (error) {
+        console.warn('AI enhancement failed, using defaults:', error);
+        // Fallback to simple analysis
+        const topics = extractTopicsFromContent(content);
+        return {
+            extractedTopics: topics,
+            expertiseLevel: 'intermediate',
+            potentialImpact: 5,
+            onboardingRelevance: false,
+        };
+    }
+}
+async function analyzeQuestionWithAI(question, entries, _teamId) {
+    try {
+        console.log(`Analyzing question with semantic search: "${question}"`);
+        // Step 1: Enhance query using Claude Haiku for better understanding
+        const queryAnalysis = await enhanceQuery(question);
+        console.log(`Query intent: ${queryAnalysis.intent}, Keywords: ${queryAnalysis.keywords.join(', ')}`);
+        // Step 2: Generate embedding for the question
+        const questionEmbedding = await generateEmbedding(question);
+        console.log(`Question embedding generated: ${questionEmbedding.length} dimensions`);
+        const scoredEntries = entries.map(entry => {
+            // Semantic similarity (if embedding available)
+            let semanticScore = 0;
+            if (questionEmbedding.length > 0 && entry.embedding && entry.embedding.length > 0) {
+                semanticScore = cosineSimilarity(questionEmbedding, entry.embedding);
+            }
+            // Enhanced keyword matching score using expanded terms from query analysis
+            const contentLower = entry.content.toLowerCase();
+            const allSearchTerms = [
+                ...queryAnalysis.keywords,
+                ...queryAnalysis.expandedTerms,
+                ...question.toLowerCase().split(/\s+/).filter(w => w.length > 3)
+            ];
+            const matchedTerms = allSearchTerms.filter(term => contentLower.includes(term.toLowerCase()));
+            const keywordScore = allSearchTerms.length > 0 ? matchedTerms.length / allSearchTerms.length : 0;
+            // Topic overlap score (boosted if matches extracted topics from query)
+            let topicScore = 0;
+            const queryTopics = [...queryAnalysis.topics, ...queryAnalysis.keywords];
+            for (const entryTopic of entry.aiTopics) {
+                if (queryTopics.some(qt => entryTopic.toLowerCase().includes(qt.toLowerCase()) ||
+                    qt.toLowerCase().includes(entryTopic.toLowerCase()))) {
+                    topicScore = 1;
+                    break;
+                }
+            }
+            // Recency score (normalize to 0-1 range)
+            const ageInDays = (Date.now() - new Date(entry.createdAt).getTime()) / MILLISECONDS_PER_DAY;
+            const recencyScore = Math.max(0, 1 - (ageInDays / RECENCY_DECAY_DAYS));
+            // Intent-based score adjustment
+            let intentBoost = 0;
+            const contentLowerForIntent = entry.content.toLowerCase();
+            const intentKeyword = INTENT_KEYWORDS[queryAnalysis.intent];
+            if (intentKeyword && contentLowerForIntent.includes(intentKeyword)) {
+                intentBoost = SCORE_WEIGHTS.intentBoost;
+            }
+            // Hybrid scoring using configured weights
+            const totalScore = (semanticScore * SCORE_WEIGHTS.semantic) +
+                (keywordScore * SCORE_WEIGHTS.keyword) +
+                (topicScore * SCORE_WEIGHTS.topic) +
+                (recencyScore * SCORE_WEIGHTS.recency) +
+                intentBoost;
+            return {
+                entry,
+                semanticScore,
+                keywordScore,
+                topicScore,
+                recencyScore,
+                totalScore
+            };
+        });
+        // Step 4: Filter and sort by total score
+        const relevantEntries = scoredEntries
+            .filter(item => item.totalScore >= RELEVANCE_THRESHOLD)
+            .sort((a, b) => b.totalScore - a.totalScore)
+            .slice(0, MAX_SEARCH_RESULTS);
+        console.log(`Found ${relevantEntries.length} relevant entries out of ${entries.length} total`);
+        // Step 5: Extract related topics from relevant entries
+        const relatedTopics = Array.from(new Set(relevantEntries.flatMap(item => item.entry.aiTopics))).slice(0, 5);
+        // Step 6: Calculate confidence based on top result score
+        const confidence = relevantEntries.length > 0 ?
+            Math.min(MAX_CONFIDENCE, relevantEntries[0].totalScore) : MIN_CONFIDENCE;
+        const topScore = relevantEntries.length > 0 ? relevantEntries[0].totalScore.toFixed(2) : 'N/A';
+        console.log(`Confidence: ${confidence.toFixed(2)}, Top score: ${topScore}, Intent: ${queryAnalysis.intent}`);
+        return {
+            relevantEntries: relevantEntries.map(item => item.entry),
+            confidence,
+            suggestedExperts: [], // Will be populated by separate expert query
+            relatedTopics,
+            timeSaved: relevantEntries.length * 5, // Estimate 5 minutes saved per relevant entry
+        };
+    }
+    catch (error) {
+        console.warn('Semantic search failed, using fallback:', error);
+        // Fallback to simple keyword matching
+        const questionLower = question.toLowerCase();
+        const relevantEntries = entries
+            .filter(entry => {
+            const contentLower = entry.content.toLowerCase();
+            return entry.aiTopics.some(topic => questionLower.includes(topic) || contentLower.includes(questionLower));
+        })
+            .sort((a, b) => b.impactScore - a.impactScore)
+            .slice(0, 10);
+        return {
+            relevantEntries,
+            confidence: relevantEntries.length > 0 ? 0.5 : 0.1,
+            suggestedExperts: [],
+            relatedTopics: Array.from(new Set(relevantEntries.flatMap(e => e.aiTopics))).slice(0, 5),
+            timeSaved: relevantEntries.length * 5,
+        };
+    }
+}
+function extractTopicsFromContent(content) {
+    const commonTech = [
+        'javascript', 'typescript', 'python', 'java', 'react', 'node',
+        'aws', 'docker', 'kubernetes', 'git', 'sql', 'api', 'rest',
+        'graphql', 'mongodb', 'postgresql', 'redis', 'lambda', 'dynamodb', 'smartagent',
+    ];
+    const contentLower = content.toLowerCase();
+    const foundTopics = commonTech.filter(tech => contentLower.includes(tech));
+    return foundTopics.length > 0 ? foundTopics.slice(0, 3) : ['general'];
+}
+//# sourceMappingURL=knowledge-ai.js.map