noverload-mcp 0.7.0 → 0.7.1

package/dist/tools/index-old.js

@@ -1,2176 +0,0 @@
-import { z } from "zod";
-import { generateLLMInstructions, planQueryStrategy, estimateTokenUsage } from "../llm-instructions.js";
-export const tools = [
-    {
-        name: "list_saved_content",
-        description: "List saved content from Noverload with full details including titles, summaries, and insights. Optionally filter by status or content type.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                status: {
-                    type: "string",
-                    enum: ["pending", "processing", "completed", "failed"],
-                    description: "Filter by processing status",
-                },
-                contentType: {
-                    type: "string",
-                    enum: ["youtube", "x_twitter", "reddit", "article", "pdf"],
-                    description: "Filter by content type",
-                },
-                limit: {
-                    type: "number",
-                    description: "Maximum number of items to return",
-                    default: 20,
-                },
-            },
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                status: z.enum(["pending", "processing", "completed", "failed"]).optional(),
-                contentType: z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"]).optional(),
-                limit: z.number().optional().default(20),
-            });
-            const params = schema.parse(args);
-            const content = await client.listContent(params);
-            // Build detailed response
-            let responseText = `# Saved Content Library\n`;
-            responseText += `Found ${content.length} items`;
-            const filters = [];
-            if (params.status)
-                filters.push(`status: ${params.status}`);
-            if (params.contentType)
-                filters.push(`type: ${params.contentType}`);
-            if (filters.length > 0) {
-                responseText += ` (filtered by ${filters.join(', ')})`;
-            }
-            responseText += `\n\n`;
-            if (content.length > 0) {
-                content.forEach((item, idx) => {
-                    responseText += `## ${idx + 1}. ${item.title || 'Untitled'}\n`;
-                    responseText += `**ID:** ${item.id}\n`;
-                    responseText += `**Type:** ${item.contentType} | **Status:** ${item.status}`;
-                    if (item.tokenCount) {
-                        responseText += ` | **Size:** ${item.tokenCount.toLocaleString()} tokens`;
-                        if (item.tokenCount > 50000) {
-                            responseText += ` 🚨`;
-                        }
-                        else if (item.tokenCount > 10000) {
-                            responseText += ` ⚠️`;
-                        }
-                    }
-                    responseText += `\n**URL:** ${item.url}\n`;
-                    if (item.summary) {
-                        const summaryObj = typeof item.summary === 'string'
-                            ? { text: item.summary }
-                            : item.summary;
-                        if (summaryObj.one_sentence) {
-                            responseText += `**Summary:** ${summaryObj.one_sentence}\n`;
-                        }
-                    }
-                    responseText += `**Saved:** ${new Date(item.createdAt).toLocaleDateString()}\n`;
-                    responseText += '\n---\n\n';
-                });
-            }
-            else {
-                responseText += "No content found matching the specified filters.";
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: content,
-            };
-        },
-    },
-    {
-        name: "get_content_details",
-        description: "Get complete details about a specific saved content item including full transcript/article text, AI-generated summary, key insights, and all metadata",
-        inputSchema: {
-            type: "object",
-            properties: {
-                contentId: {
-                    type: "string",
-                    description: "The ID of the content to retrieve",
-                },
-            },
-            required: ["contentId"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                contentId: z.string(),
-            });
-            const { contentId } = schema.parse(args);
-            const content = await client.getContent(contentId);
-            // Build comprehensive response with all details
-            let responseText = `# Content Details: ${content.title || 'Untitled'}\n\n`;
-            responseText += `**ID:** ${content.id}\n`;
-            responseText += `**Type:** ${content.contentType}\n`;
-            responseText += `**Status:** ${content.status}\n`;
-            responseText += `**URL:** ${content.url}\n`;
-            responseText += `**Saved:** ${new Date(content.createdAt).toLocaleDateString()}\n`;
-            // Show content size information
-            if (content.tokenCount) {
-                responseText += `**Full Content Size:** ${content.tokenCount.toLocaleString()} tokens`;
-                if (content.tokenCount > 50000) {
-                    responseText += ` 🚨 EXTREMELY LARGE`;
-                }
-                else if (content.tokenCount > 10000) {
-                    responseText += ` ⚠️ LARGE`;
-                }
-                responseText += '\n';
-            }
-            if (content.tags && content.tags.length > 0) {
-                responseText += `**Tags:** ${content.tags.join(', ')}\n`;
-            }
-            responseText += '\n## Summary & Insights\n';
-            if (content.summary) {
-                const summaryObj = typeof content.summary === 'string'
-                    ? { text: content.summary }
-                    : content.summary;
-                if (summaryObj.one_sentence) {
-                    responseText += `**One-line Summary:** ${summaryObj.one_sentence}\n\n`;
-                }
-                if (summaryObj.key_insights && Array.isArray(summaryObj.key_insights)) {
-                    responseText += `**Key Insights:**\n`;
-                    summaryObj.key_insights.forEach((insight, idx) => {
-                        responseText += `${idx + 1}. ${insight}\n`;
-                    });
-                    responseText += '\n';
-                }
-                if (summaryObj.main_topics && Array.isArray(summaryObj.main_topics)) {
-                    responseText += `**Main Topics:** ${summaryObj.main_topics.join(', ')}\n\n`;
-                }
-                if (summaryObj.actionable_takeaways && Array.isArray(summaryObj.actionable_takeaways)) {
-                    responseText += `**Actionable Takeaways:**\n`;
-                    summaryObj.actionable_takeaways.forEach((takeaway, idx) => {
-                        responseText += `${idx + 1}. ${takeaway}\n`;
-                    });
-                    responseText += '\n';
-                }
-            }
-            // Include full text content info and preview
-            if (content.rawText) {
-                const wordCount = content.rawText.split(/\s+/).length;
-                responseText += `## Full Content\n`;
-                responseText += `**Word Count:** ${wordCount.toLocaleString()} words\n`;
-                // Show a reasonable preview (500 chars is about 100 tokens)
-                responseText += `**Preview (first 500 chars):**\n`;
-                responseText += `${content.rawText.slice(0, 500)}...\n\n`;
-                if (content.tokenCount && content.tokenCount > 10000) {
-                    responseText += `⚠️ **Note:** The complete ${content.contentType} content (${wordCount.toLocaleString()} words, ~${content.tokenCount.toLocaleString()} tokens) is available in the data field.\n`;
-                    responseText += `This is a large amount of content that will consume significant context if fully processed.\n`;
-                }
-                else {
-                    responseText += `*Note: Complete content is available in the data field for analysis.*\n`;
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: content, // Full content including complete rawText
-            };
-        },
-    },
-    {
-        name: "search_content",
-        description: "Advanced search with OR/ANY logic, fuzzy matching, and smart filters. Supports multiple search modes, content type filtering, date ranges, and relevance explanations.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query (supports 'term1 OR term2' for any match, quotes for exact phrases)",
-                },
-                searchMode: {
-                    type: "string",
-                    enum: ["any", "all", "phrase"],
-                    description: "Search logic: 'any' (OR logic), 'all' (AND logic), 'phrase' (exact phrase)",
-                    default: "any",
-                },
-                fuzzyMatch: {
-                    type: "boolean",
-                    description: "Enable fuzzy/typo-tolerant matching",
-                    default: true,
-                },
-                tags: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "Filter by tags",
-                },
-                limit: {
-                    type: "number",
-                    description: "Maximum results (default: 10)",
-                    default: 10,
-                },
-                includeFullContent: {
-                    type: "boolean",
-                    description: "Include full text (WARNING: 10k-100k+ tokens)",
-                    default: false,
-                },
-                contentTypes: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                        enum: ["youtube", "x_twitter", "reddit", "article", "pdf"],
-                    },
-                    description: "Filter by content types",
-                },
-                dateFrom: {
-                    type: "string",
-                    description: "Content saved after this date (ISO 8601)",
-                },
-                dateTo: {
-                    type: "string",
-                    description: "Content saved before this date (ISO 8601)",
-                },
-                excludeDomains: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "Domains to exclude",
-                },
-                showRelevanceExplanation: {
-                    type: "boolean",
-                    description: "Show why each result matched",
-                    default: true,
-                },
-            },
-            required: ["query"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                query: z.string(),
-                searchMode: z.enum(["any", "all", "phrase"]).optional().default("any"),
-                fuzzyMatch: z.boolean().optional().default(true),
-                tags: z.array(z.string()).optional(),
-                limit: z.number().optional().default(10),
-                includeFullContent: z.boolean().optional().default(false),
-                contentTypes: z.array(z.enum(["youtube", "x_twitter", "reddit", "article", "pdf"])).optional(),
-                dateFrom: z.string().optional(),
-                dateTo: z.string().optional(),
-                excludeDomains: z.array(z.string()).optional(),
-                showRelevanceExplanation: z.boolean().optional().default(true),
-            });
-            const params = schema.parse(args);
-            // Enhance search query based on mode
-            let enhancedQuery = params.query;
-            if (params.searchMode === "any" && !params.query.includes("OR")) {
-                // Convert space-separated terms to OR query for broader matching
-                const terms = params.query.split(/\s+/).filter(t => t.length > 2);
-                if (terms.length > 1) {
-                    enhancedQuery = terms.join(" OR ");
-                }
-            }
-            const results = await client.searchContent(enhancedQuery, {
-                ...params,
-                enableConceptExpansion: params.fuzzyMatch, // Use fuzzy matching as concept expansion
-            });
-            // Format response with visual indicators
-            let responseText = `# 🔍 Search Results: "${params.query}"\n`;
-            responseText += `**Mode:** ${params.searchMode.toUpperCase()}${params.fuzzyMatch ? " with fuzzy matching" : ""}\n`;
-            responseText += `**Found:** ${results.length} results`;
-            // Show active filters
-            const filters = [];
-            if (params.tags?.length)
-                filters.push(`📌 tags: ${params.tags.join(", ")}`);
-            if (params.contentTypes?.length)
-                filters.push(`📁 types: ${params.contentTypes.join(", ")}`);
-            if (params.dateFrom || params.dateTo)
-                filters.push(`📅 date range`);
-            if (params.excludeDomains?.length)
-                filters.push(`🚫 excluded: ${params.excludeDomains.join(", ")}`);
-            if (filters.length > 0) {
-                responseText += `\n**Filters:** ${filters.join(" | ")}`;
-            }
-            if (params.includeFullContent) {
-                responseText += `\n⚠️ **Full content included** - consuming significant tokens`;
-            }
-            responseText += `\n\n`;
-            if (results.length > 0) {
-                // Add search suggestions if no perfect matches
-                if (results.length < 3) {
-                    responseText += `💡 **Tip:** Try broader search with 'any' mode or disable filters for more results\n\n`;
-                }
-                results.forEach((result, idx) => {
-                    // Visual indicators for content type
-                    const typeIcons = {
-                        youtube: "📺",
-                        x_twitter: "𝕏",
-                        reddit: "🔗",
-                        article: "📄",
-                        pdf: "📑"
-                    };
-                    const typeIcon = typeIcons[result.contentType] || "📄";
-                    // Relevance indicator
-                    let relevanceIcon = "";
-                    if (result.relevanceScore) {
-                        if (result.relevanceScore > 0.8)
-                            relevanceIcon = "🎯";
-                        else if (result.relevanceScore > 0.6)
-                            relevanceIcon = "✅";
-                        else if (result.relevanceScore > 0.4)
-                            relevanceIcon = "➡️";
-                    }
-                    responseText += `## ${idx + 1}. ${typeIcon} ${result.title || 'Untitled'} ${relevanceIcon}\n`;
-                    responseText += `**ID:** \`${result.id}\`\n`;
-                    responseText += `**URL:** ${result.url}\n`;
-                    // Show relevance explanation if available
-                    if (params.showRelevanceExplanation) {
-                        if (result.matchReason && Array.isArray(result.matchReason)) {
-                            responseText += `**Why matched:** Matched in ${result.matchReason.join(", ")}\n`;
-                        }
-                        else if (result.relevanceScore) {
-                            const percentage = (result.relevanceScore * 100).toFixed(0);
-                            responseText += `**Relevance:** ${percentage}% match\n`;
-                        }
-                    }
-                    // Content size indicator with better formatting
-                    if (result.tokenCount) {
-                        const sizeIcon = result.tokenCount > 50000 ? "🚨" :
-                            result.tokenCount > 10000 ? "⚠️" :
-                                result.tokenCount > 5000 ? "📊" : "📝";
-                        responseText += `**Size:** ${sizeIcon} ~${result.tokenCount.toLocaleString()} tokens`;
-                        if (params.includeFullContent) {
-                            responseText += ` (full content included)`;
-                        }
-                        responseText += `\n`;
-                    }
-                    // Tags with better formatting
-                    if (result.tags && result.tags.length > 0) {
-                        responseText += `**Tags:** ${result.tags.map((t) => `\`${t}\``).join(' ')}\n`;
-                    }
-                    // Summary section with structure
-                    if (result.summary) {
-                        const summaryObj = typeof result.summary === 'string'
-                            ? { text: result.summary }
-                            : result.summary;
-                        if (summaryObj.one_sentence) {
-                            responseText += `\n📝 **Summary:** ${summaryObj.one_sentence}\n`;
-                        }
-                        // Key insights with bullets
-                        if (summaryObj.key_insights && Array.isArray(summaryObj.key_insights) && summaryObj.key_insights.length > 0) {
-                            responseText += `\n💡 **Key Insights:**\n`;
-                            summaryObj.key_insights.slice(0, 3).forEach((insight) => {
-                                responseText += `  • ${insight}\n`;
-                            });
-                        }
-                        // Actionable takeaways
-                        if (summaryObj.actionable_takeaways && Array.isArray(summaryObj.actionable_takeaways) && summaryObj.actionable_takeaways.length > 0) {
-                            responseText += `\n🎯 **Actions:**\n`;
-                            summaryObj.actionable_takeaways.slice(0, 2).forEach((action) => {
-                                responseText += `  → ${action}\n`;
-                            });
-                        }
-                    }
-                    responseText += '\n---\n\n';
-                });
-                // Smart token usage summary
-                if (!params.includeFullContent) {
-                    let totalAvailable = 0;
-                    results.forEach((r) => {
-                        if (r.tokenCount)
-                            totalAvailable += r.tokenCount;
-                    });
-                    if (totalAvailable > 0) {
-                        responseText += `\n📊 **Content Overview:**\n`;
-                        responseText += `- Showing: Summaries and metadata (minimal tokens)\n`;
-                        responseText += `- Available: ~${totalAvailable.toLocaleString()} tokens of full content\n`;
-                        responseText += `- To access: Use \`get_content_details\` for specific items\n`;
-                    }
-                }
-                // Search quality feedback
-                if (results.length === params.limit) {
-                    responseText += `\n💡 **Note:** Showing top ${params.limit} results. More may be available.\n`;
-                }
-            }
-            else {
-                // No results - provide helpful suggestions
-                responseText += "## No Results Found 😔\n\n";
-                responseText += "**Try these approaches:**\n";
-                responseText += "1. 🔄 Switch to `searchMode: 'any'` for broader matching\n";
-                responseText += "2. ✏️ Check spelling or use simpler terms\n";
-                responseText += "3. 🎯 Remove filters (dates, types, domains)\n";
-                responseText += "4. 🔍 Use more general keywords\n";
-                // Suggest alternative queries
-                const terms = params.query.split(/\s+/);
-                if (terms.length > 1) {
-                    responseText += `\n**Alternative queries:**\n`;
-                    responseText += `- "${terms[0]}" (single term)\n`;
-                    responseText += `- "${terms.slice(0, 2).join(' ')}" (first two terms)\n`;
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: results,
-            };
-        },
-    },
-    {
-        name: "save_content",
-        description: "Save a new URL to Noverload for processing",
-        inputSchema: {
-            type: "object",
-            properties: {
-                url: {
-                    type: "string",
-                    description: "URL to save (YouTube, X/Twitter, Reddit, article, or PDF)",
-                },
-            },
-            required: ["url"],
-        },
-        modifies: true,
-        handler: async (client, args) => {
-            const schema = z.object({
-                url: z.string().url(),
-            });
-            const { url } = schema.parse(args);
-            const content = await client.saveContent(url);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content.title ? `Saved: ${content.title}` : `Saved content from: ${new URL(url).hostname}`,
-                    },
-                ],
-                data: content,
-            };
-        },
-    },
-    {
-        name: "list_actions",
-        description: "List action items extracted from saved content",
-        inputSchema: {
-            type: "object",
-            properties: {
-                contentId: {
-                    type: "string",
-                    description: "Filter by content ID",
-                },
-                goalId: {
-                    type: "string",
-                    description: "Filter by goal ID",
-                },
-                completed: {
-                    type: "boolean",
-                    description: "Filter by completion status",
-                },
-            },
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                contentId: z.string().optional(),
-                goalId: z.string().optional(),
-                completed: z.boolean().optional(),
-            });
-            const params = schema.parse(args);
-            const actions = await client.listActions(params);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Found ${actions.length} actions`,
-                    },
-                ],
-                data: actions,
-            };
-        },
-    },
-    {
-        name: "complete_action",
-        description: "Mark an action item as completed",
-        inputSchema: {
-            type: "object",
-            properties: {
-                actionId: {
-                    type: "string",
-                    description: "The ID of the action to complete",
-                },
-            },
-            required: ["actionId"],
-        },
-        modifies: true,
-        handler: async (client, args) => {
-            const schema = z.object({
-                actionId: z.string(),
-            });
-            const { actionId } = schema.parse(args);
-            const action = await client.completeAction(actionId);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Completed action: ${action.title}`,
-                    },
-                ],
-                data: action,
-            };
-        },
-    },
-    {
-        name: "list_goals",
-        description: "List user's goals (Health, Wealth, Relationships)",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-        modifies: false,
-        handler: async (client) => {
-            const goals = await client.listGoals();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Found ${goals.length} goals`,
-                    },
-                ],
-                data: goals,
-            };
-        },
-    },
-    {
-        name: "estimate_search_tokens",
-        description: "Estimate token usage before performing a search. Helps manage context window and API costs.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query to estimate",
-                },
-                limit: {
-                    type: "number",
-                    description: "Number of results to estimate for",
-                    default: 10,
-                },
-            },
-            required: ["query"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                query: z.string(),
-                limit: z.number().optional().default(10),
-            });
-            const params = schema.parse(args);
-            const estimate = await client.estimateSearchTokens(params.query, params.limit);
-            let responseText = `# Token Estimate for: "${params.query}"\n\n`;
-            responseText += `**Total Estimated Tokens:** ${estimate.totals?.estimatedTokens || 0}\n`;
-            responseText += `**Recommendation:** ${estimate.recommendation || "Unknown"}\n\n`;
-            if (estimate.costEstimate) {
-                responseText += `## Estimated Costs\n`;
-                responseText += `- GPT-4: ${estimate.costEstimate.gpt4}\n`;
-                responseText += `- GPT-3.5: ${estimate.costEstimate.gpt35}\n`;
-                responseText += `- Claude 3: ${estimate.costEstimate.claude3}\n\n`;
-            }
-            if (estimate.estimates && estimate.estimates.length > 0) {
-                responseText += `## Content Breakdown\n`;
-                estimate.estimates.forEach((item, idx) => {
-                    responseText += `${idx + 1}. ${item.title || "Untitled"} - ${item.estimatedTokens} tokens\n`;
-                });
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: estimate,
-            };
-        },
-    },
-    {
-        name: "synthesize_content",
-        description: "Analyze multiple content sources to generate actionable insights, find patterns, connections, and contradictions. Creates structured synthesis with timeline, next steps, and confidence scores.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Topic or question to synthesize insights about",
-                },
-                contentIds: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "Specific content IDs to analyze (optional, otherwise uses search)",
-                },
-                synthesisMode: {
-                    type: "string",
-                    enum: ["overview", "deep", "actionable", "comparison"],
-                    description: "Type of synthesis to perform (default: actionable)",
-                    default: "actionable",
-                },
-                findContradictions: {
-                    type: "boolean",
-                    description: "Look for contradictions between sources",
-                    default: false,
-                },
-                findConnections: {
-                    type: "boolean",
-                    description: "Find connections and patterns across sources",
-                    default: true,
-                },
-                maxSources: {
-                    type: "number",
-                    description: "Maximum number of sources to analyze",
-                    default: 10,
-                },
-            },
-            required: ["query"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                query: z.string(),
-                contentIds: z.array(z.string()).optional(),
-                synthesisMode: z.enum(["overview", "deep", "actionable", "comparison"]).optional().default("actionable"),
-                findContradictions: z.boolean().optional().default(false),
-                findConnections: z.boolean().optional().default(true),
-                maxSources: z.number().optional().default(10),
-            });
-            const params = schema.parse(args);
-            const result = await client.synthesizeContent(params);
-            // Handle the API v2 response format
-            const synthesis = result.synthesis || result;
-            const metadata = result.metadata || {};
-            const sources = result.sources || [];
-            let responseText = `# 🎯 Synthesis: "${params.query}"\n`;
-            responseText += `**Mode:** ${synthesis.mode || params.synthesisMode} | **Sources:** ${metadata.sourceCount || sources.length}`;
-            // Add confidence indicator if available
-            if (metadata.confidence) {
-                const confidenceIcon = metadata.confidence >= 80 ? "🟢" : metadata.confidence >= 60 ? "🟡" : "🔴";
-                responseText += ` | **Confidence:** ${confidenceIcon} ${metadata.confidence}%`;
-            }
-            responseText += `\n\n`;
-            // Summary Section
-            if (synthesis.summary) {
-                responseText += `## 📋 Summary\n${synthesis.summary}\n\n`;
-            }
-            // Insights Section (most important)
-            if (synthesis.insights && synthesis.insights.length > 0) {
-                responseText += `## 💡 Key Insights\n`;
-                synthesis.insights.forEach((insight, idx) => {
-                    // Handle both string and object insights
-                    if (typeof insight === 'string') {
-                        responseText += `${idx + 1}. ${insight}\n`;
-                    }
-                    else if (insight.text) {
-                        responseText += `${idx + 1}. **${insight.text}**`;
-                        if (insight.sourceTitle) {
-                            responseText += ` *(from: ${insight.sourceTitle})*`;
-                        }
-                        responseText += `\n`;
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Themes Section
-            if (synthesis.themes && synthesis.themes.length > 0) {
-                responseText += `## 🎨 Major Themes\n`;
-                synthesis.themes.forEach((theme) => {
-                    if (typeof theme === 'string') {
-                        responseText += `- ${theme}\n`;
-                    }
-                    else if (theme.theme) {
-                        responseText += `\n### ${theme.theme}`;
-                        if (theme.prevalence) {
-                            responseText += ` (strength: ${theme.prevalence})`;
-                        }
-                        responseText += `\n`;
-                        if (theme.concepts && theme.concepts.length > 0) {
-                            responseText += `Related concepts: `;
-                            responseText += theme.concepts.slice(0, 3).map((c) => typeof c === 'string' ? c : c.concept).join(', ');
-                            responseText += `\n`;
-                        }
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Priorities (for actionable mode)
-            if (synthesis.priorities) {
-                responseText += `## 🎯 Priorities\n`;
-                if (synthesis.priorities.high && synthesis.priorities.high.length > 0) {
-                    responseText += `\n### 🔴 High Priority\n`;
-                    synthesis.priorities.high.forEach((item) => {
-                        responseText += `- ${item}\n`;
-                    });
-                }
-                if (synthesis.priorities.medium && synthesis.priorities.medium.length > 0) {
-                    responseText += `\n### 🟡 Medium Priority\n`;
-                    synthesis.priorities.medium.forEach((item) => {
-                        responseText += `- ${item}\n`;
-                    });
-                }
-                if (synthesis.priorities.low && synthesis.priorities.low.length > 0) {
-                    responseText += `\n### 🟢 Low Priority\n`;
-                    synthesis.priorities.low.forEach((item) => {
-                        responseText += `- ${item}\n`;
-                    });
-                }
-                responseText += `\n`;
-            }
-            // Implementation Steps (for actionable mode)
-            if (synthesis.implementation && synthesis.implementation.length > 0) {
-                responseText += `## 📝 Implementation Steps\n`;
-                synthesis.implementation.forEach((step, idx) => {
-                    responseText += `${idx + 1}. ${step}\n`;
-                });
-                responseText += `\n`;
-            }
-            // Source Comparison (for comparative mode)
-            if (synthesis.sourceComparison && synthesis.sourceComparison.length > 0) {
-                responseText += `## 📊 Source Comparison\n`;
-                synthesis.sourceComparison.forEach((source) => {
-                    responseText += `\n### ${source.source}\n`;
-                    responseText += `- **Insights:** ${source.insightCount}\n`;
-                    if (source.mainThemes && source.mainThemes.length > 0) {
-                        responseText += `- **Main themes:** ${source.mainThemes.join(', ')}\n`;
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Commonalities and Differences
-            if (synthesis.commonalities && synthesis.commonalities.length > 0) {
-                responseText += `## ✅ Common Themes Across Sources\n`;
-                synthesis.commonalities.forEach((theme) => {
-                    responseText += `- ${theme}\n`;
-                });
-                responseText += `\n`;
-            }
-            if (synthesis.differences && synthesis.differences.length > 0) {
-                responseText += `## 🔀 Unique Perspectives\n`;
-                synthesis.differences.forEach((diff) => {
-                    responseText += `- **${diff.source}:** ${diff.themes.join(', ')}\n`;
-                });
-                responseText += `\n`;
-            }
-            // Connections
-            if (synthesis.connections && synthesis.connections.length > 0) {
-                responseText += `## 🔗 Connections & Patterns\n`;
-                synthesis.connections.forEach((conn) => {
-                    if (conn.concept && conn.sources) {
-                        responseText += `- **${conn.concept}** appears in: ${conn.sources.join(', ')}`;
-                        if (conn.strength) {
-                            responseText += ` (strength: ${conn.strength})`;
-                        }
-                        responseText += `\n`;
-                    }
-                    else if (conn.pattern) {
-                        responseText += `- **${conn.pattern}**`;
-                        if (conn.implication) {
-                            responseText += `: ${conn.implication}`;
-                        }
-                        responseText += `\n`;
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Contradictions
-            if (synthesis.contradictions && synthesis.contradictions.length > 0) {
-                responseText += `## ⚡ Contradictions Found\n`;
-                synthesis.contradictions.forEach((contra) => {
-                    if (contra.source1 && contra.statement1) {
-                        responseText += `\n### Potential Contradiction\n`;
-                        responseText += `- **${contra.source1}:** "${contra.statement1}"\n`;
-                        responseText += `- **${contra.source2}:** "${contra.statement2}"\n`;
-                        if (contra.type) {
-                            responseText += `- **Type:** ${contra.type}\n`;
-                        }
-                    }
-                    else if (contra.topic) {
-                        responseText += `\n### ${contra.topic}\n`;
-                        if (contra.viewpoints) {
-                            contra.viewpoints.forEach((vp) => {
-                                responseText += `- **${vp.position}:** ${vp.argument}\n`;
-                            });
-                        }
-                        if (contra.resolution) {
-                            responseText += `**Suggested resolution:** ${contra.resolution}\n`;
-                        }
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Timeline
-            if (synthesis.timeline && synthesis.timeline.length > 0) {
-                responseText += `## ⏱️ Timeline\n`;
-                synthesis.timeline.forEach((event) => {
-                    if (event.date) {
-                        responseText += `- **${event.date}:** ${event.event}`;
-                        if (event.source) {
-                            responseText += ` *(${event.source})*`;
-                        }
-                        responseText += `\n`;
-                    }
-                    else if (event.phase) {
-                        responseText += `\n### ${event.phase}`;
-                        if (event.duration) {
-                            responseText += ` (${event.duration})`;
-                        }
-                        responseText += `\n`;
-                        if (event.activities && event.activities.length > 0) {
-                            event.activities.forEach((activity) => {
-                                responseText += `- ${activity}\n`;
-                            });
-                        }
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Action Plan
-            if (synthesis.actionPlan) {
-                responseText += `## 🚀 Action Plan\n`;
-                if (synthesis.actionPlan.summary) {
-                    responseText += `${synthesis.actionPlan.summary}\n\n`;
-                }
-                if (synthesis.actionPlan.nextAction) {
-                    responseText += `**🎯 Next Action:** ${synthesis.actionPlan.nextAction.action || synthesis.actionPlan.nextAction}\n\n`;
-                }
-                if (synthesis.actionPlan.steps && synthesis.actionPlan.steps.length > 0) {
-                    responseText += `### Steps\n`;
-                    synthesis.actionPlan.steps.forEach((step, idx) => {
-                        const priorityIcon = step.priority === "high" ? "🔴" : step.priority === "medium" ? "🟡" : "🟢";
-                        responseText += `${idx + 1}. ${priorityIcon} **${step.action}**`;
-                        if (step.timeframe) {
-                            responseText += ` *(${step.timeframe})*`;
-                        }
-                        if (step.reasoning) {
-                            responseText += `\n   - Reasoning: ${step.reasoning}`;
-                        }
-                        responseText += `\n`;
-                    });
-                }
-                responseText += `\n`;
-            }
-            // Key Facts (if available)
-            if (synthesis.keyFacts && synthesis.keyFacts.length > 0) {
-                responseText += `## 📌 Key Facts\n`;
-                synthesis.keyFacts.slice(0, 5).forEach((fact) => {
-                    if (typeof fact === 'string') {
-                        responseText += `- ${fact}\n`;
-                    }
-                    else if (fact.text) {
-                        responseText += `- ${fact.text}`;
-                        if (fact.sourceTitle) {
-                            responseText += ` *(${fact.sourceTitle})*`;
-                        }
-                        responseText += `\n`;
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Source Information
-            if (sources && sources.length > 0) {
-                responseText += `## 📚 Sources Analyzed\n`;
-                sources.forEach((source, idx) => {
-                    const typeIcons = {
-                        youtube: "📺",
-                        x_twitter: "𝕏",
-                        reddit: "🔗",
-                        article: "📄",
-                        pdf: "📑"
-                    };
-                    const typeIcon = typeIcons[source.type] || "📄";
-                    responseText += `${idx + 1}. ${typeIcon} [${source.title}](${source.url})\n`;
-                });
-                responseText += `\n`;
-            }
-            // Metadata Footer
-            responseText += `---\n`;
-            responseText += `*Analysis completed in ${metadata.executionTime ? `${metadata.executionTime}ms` : 'N/A'}`;
-            if (metadata.totalTokens) {
-                responseText += ` | Processed ${metadata.totalTokens.toLocaleString()} tokens`;
-            }
-            if (metadata.focusAreas && metadata.focusAreas.length > 0) {
-                responseText += ` | Focus: ${metadata.focusAreas.join(', ')}`;
-            }
-            responseText += `*\n`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: result,
-            };
-        },
-    },
-    {
-        name: "find_similar_content",
-        description: "Find content similar to a specific saved item using semantic similarity.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                contentId: {
-                    type: "string",
-                    description: "ID of the content to find similar items for",
-                },
-                limit: {
-                    type: "number",
-                    description: "Maximum number of similar items to return",
-                    default: 5,
-                },
-                minSimilarity: {
-                    type: "number",
-                    description: "Minimum similarity score (0-1)",
-                    default: 0.7,
-                },
-            },
-            required: ["contentId"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                contentId: z.string(),
-                limit: z.number().optional().default(5),
-                minSimilarity: z.number().optional().default(0.7),
-            });
-            const params = schema.parse(args);
-            const result = await client.findSimilarContent(params.contentId, {
-                limit: params.limit,
-                minSimilarity: params.minSimilarity,
-            });
-            let responseText = `# Similar Content to: ${result.source?.title || "Unknown"}\n\n`;
-            if (result.similarContent && result.similarContent.length > 0) {
-                responseText += `Found ${result.similarContent.length} similar items:\n\n`;
-                result.similarContent.forEach((item, idx) => {
-                    responseText += `## ${idx + 1}. ${item.title || "Untitled"}\n`;
-                    responseText += `**Similarity:** ${(item.similarity * 100).toFixed(1)}%\n`;
-                    responseText += `**Type:** ${item.type || item.contentType || "unknown"} | **URL:** ${item.url}\n`;
-                    if (item.summary) {
-                        responseText += `**Summary:** ${item.summary}\n`;
-                    }
-                    responseText += `\n`;
-                });
-            }
-            else {
-                responseText += `No similar content found with similarity >= ${params.minSimilarity}`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: result,
-            };
-        },
-    },
-    {
-        name: "batch_get_content",
-        description: "Fetch multiple content items in a single request. Efficient for bulk operations.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                ids: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "Array of content IDs to fetch",
-                },
-                includeFullContent: {
-                    type: "boolean",
-                    description: "Include full text content (warning: may use many tokens)",
-                    default: false,
-                },
-            },
-            required: ["ids"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                ids: z.array(z.string()).min(1).max(50),
-                includeFullContent: z.boolean().optional().default(false),
-            });
-            const params = schema.parse(args);
-            const result = await client.batchGetContent(params.ids, params.includeFullContent);
-            let responseText = `# Batch Content Fetch\n\n`;
-            responseText += `Requested: ${params.ids.length} items\n`;
-            responseText += `Found: ${result.metadata?.found || 0} items\n`;
-            // Calculate and warn about total tokens
-            let totalTokens = 0;
-            if (result.results && result.results.length > 0) {
-                result.results.forEach((item) => {
-                    if (item.tokenCount)
-                        totalTokens += item.tokenCount;
-                });
-            }
-            if (params.includeFullContent && totalTokens > 0) {
-                responseText += `\n⚠️ **Full Content Included - Total Size: ${totalTokens.toLocaleString()} tokens**`;
-                if (totalTokens > 100000) {
-                    responseText += ` 🚨 EXTREMELY LARGE!\n`;
-                    responseText += `WARNING: This WILL consume most or all of your context window!\n`;
-                    responseText += `Consider setting includeFullContent: false to just get summaries.\n`;
-                }
-                else if (totalTokens > 50000) {
-                    responseText += ` 🚨 VERY LARGE!\n`;
-                    responseText += `This is consuming significant context. Use with caution.\n`;
-                }
-                else if (totalTokens > 10000) {
-                    responseText += ` ⚠️\n`;
-                }
-                else {
-                    responseText += `\n`;
-                }
-            }
-            else if (!params.includeFullContent && totalTokens > 0) {
-                responseText += `\n💡 **Showing summaries only.** Total content available: ~${totalTokens.toLocaleString()} tokens.\n`;
-                responseText += `Rich metadata (summaries, tags, insights) included with minimal token usage.\n`;
-            }
-            responseText += `\n`;
-            if (result.results && result.results.length > 0) {
-                result.results.forEach((item, idx) => {
-                    if (item.error) {
-                        responseText += `## ${idx + 1}. Error: ${item.id}\n`;
-                        responseText += `${item.error}\n\n`;
-                    }
-                    else {
-                        responseText += `## ${idx + 1}. ${item.title || "Untitled"}\n`;
-                        responseText += `**ID:** ${item.id}\n`;
-                        responseText += `**Type:** ${item.contentType} | **URL:** ${item.url}\n`;
-                        if (item.tokenCount) {
-                            responseText += `**Tokens:** ${item.tokenCount.toLocaleString()}`;
-                            if (item.tokenCount > 10000)
-                                responseText += ` ⚠️`;
-                            responseText += `\n`;
-                        }
-                        if (item.summary) {
-                            responseText += `**Summary:** ${typeof item.summary === "string" ? item.summary : item.summary.one_sentence || "N/A"}\n`;
-                        }
-                        if (params.includeFullContent && item.fullContent) {
-                            responseText += `**Content Length:** ${item.metadata?.contentLength || 0} characters\n`;
-                        }
-                        responseText += `\n`;
-                    }
-                });
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: result,
-            };
-        },
-    },
-    {
-        name: "get_instructions",
-        description: "Get instructions for optimal MCP usage, including capabilities, best practices, and example workflows",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: {
-                    type: "string",
-                    description: "Specific topic for instructions (optional)",
-                    enum: ["search", "synthesis", "retrieval", "general"],
-                },
-                includeExamples: {
-                    type: "boolean",
-                    description: "Include workflow examples",
-                    default: true,
-                },
-            },
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                topic: z.enum(["search", "synthesis", "retrieval", "general"]).optional(),
-                includeExamples: z.boolean().optional().default(true),
-            });
-            const params = schema.parse(args);
-            const instructions = generateLLMInstructions();
-            let responseText = `# Noverload MCP Usage Instructions\n\n`;
-            responseText += `## Version: ${instructions.version}\n\n`;
-            if (!params.topic || params.topic === "general") {
-                // Show all capabilities
-                responseText += `## Capabilities Overview\n\n`;
-                for (const [key, capability] of Object.entries(instructions.capabilities)) {
-                    responseText += `### ${key.charAt(0).toUpperCase() + key.slice(1)}\n`;
-                    responseText += `${capability.description}\n\n`;
-                    responseText += `**Strengths:**\n`;
-                    capability.strengths.forEach((s) => responseText += `- ${s}\n`);
-                    responseText += `\n**When to use:**\n`;
-                    capability.whenToUse.forEach((w) => responseText += `- ${w}\n`);
-                    responseText += `\n`;
-                }
-                responseText += `## Best Practices\n\n`;
-                for (const [scenario, practice] of Object.entries(instructions.bestPractices)) {
-                    responseText += `**${scenario.replace(/([A-Z])/g, ' $1').toLowerCase()}:** ${practice}\n`;
-                }
-                responseText += `\n`;
-            }
-            else {
-                // Show specific capability
-                const capability = instructions.capabilities[params.topic];
-                if (capability) {
-                    responseText += `## ${params.topic.charAt(0).toUpperCase() + params.topic.slice(1)} Capability\n\n`;
-                    responseText += `${capability.description}\n\n`;
-                    responseText += `### Strengths\n`;
-                    capability.strengths.forEach(s => responseText += `- ${s}\n`);
-                    responseText += `\n### Limitations\n`;
-                    capability.limitations.forEach(l => responseText += `- ${l}\n`);
-                    responseText += `\n### When to Use\n`;
-                    capability.whenToUse.forEach(w => responseText += `- ${w}\n`);
-                }
-            }
-            if (params.includeExamples && instructions.exampleWorkflows.length > 0) {
-                responseText += `\n## Example Workflows\n\n`;
-                instructions.exampleWorkflows.forEach((example, idx) => {
-                    responseText += `### ${idx + 1}. ${example.scenario}\n`;
-                    responseText += `**Steps:**\n`;
-                    example.steps.forEach((step, i) => responseText += `${i + 1}. ${step}\n`);
-                    responseText += `**Expected Outcome:** ${example.expectedOutcome}\n\n`;
-                });
-            }
-            responseText += `## Token Management\n\n`;
-            responseText += `- Search results limit: ${instructions.tokenManagement.searchResultsLimit}\n`;
-            responseText += `- Use chunking: ${instructions.tokenManagement.useChunking ? 'Yes' : 'No'}\n`;
-            responseText += `- Get summaries first: ${instructions.tokenManagement.summaryFirst ? 'Yes' : 'No'}\n`;
-            responseText += `- Max content per query: ${instructions.tokenManagement.maxContentPerQuery.toLocaleString()} tokens\n`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: instructions,
-            };
-        },
-    },
-    {
-        name: "plan_query",
-        description: "Plan an optimal query strategy for complex requests, with token estimates",
-        inputSchema: {
-            type: "object",
-            properties: {
-                request: {
-                    type: "string",
-                    description: "The user's request to plan for",
-                },
-            },
-            required: ["request"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                request: z.string(),
-            });
-            const { request } = schema.parse(args);
-            const availableTools = [
-                "search_content",
-                "get_content_details",
-                "synthesize_content",
-                "find_similar_content",
-                "list_saved_content"
-            ];
-            const plan = planQueryStrategy(request, availableTools);
-            let responseText = `# Query Plan for: "${request}"\n\n`;
-            responseText += `## Strategy: ${plan.strategy}\n`;
-            responseText += `## Estimated Tokens: ~${plan.estimatedTokens.toLocaleString()}\n\n`;
-            responseText += `## Execution Steps:\n\n`;
-            plan.steps.forEach((step, idx) => {
-                responseText += `### Step ${idx + 1}: ${step.tool}\n`;
-                responseText += `**Purpose:** ${step.purpose}\n`;
-                responseText += `**Parameters:**\n`;
-                for (const [key, value] of Object.entries(step.params)) {
-                    responseText += `- ${key}: ${JSON.stringify(value)}\n`;
-                }
-                const tokenEstimate = estimateTokenUsage({ tool: step.tool, params: step.params });
-                responseText += `**Estimated Tokens:** ~${tokenEstimate.estimated.toLocaleString()}`;
-                if (tokenEstimate.warning) {
-                    responseText += ` ⚠️ ${tokenEstimate.warning}`;
-                }
-                responseText += `\n`;
-                if (tokenEstimate.suggestion) {
-                    responseText += `**Suggestion:** ${tokenEstimate.suggestion}\n`;
-                }
-                responseText += `\n`;
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: plan,
-            };
-        },
-    },
-    {
-        name: "get_raw_content",
-        description: "Access full raw text of saved content with smart chunking for large documents. Requires confirmation for content >10k tokens. Returns complete unprocessed text or intelligently chunked sections.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                contentId: {
-                    type: "string",
-                    description: "The ID of the content to retrieve raw text for",
-                },
-                format: {
-                    type: "string",
-                    enum: ["full", "chunks", "sections"],
-                    description: "Format: 'full' (complete text), 'chunks' (semantic chunks), 'sections' (logical sections)",
-                    default: "chunks",
-                },
-                maxTokens: {
-                    type: "number",
-                    description: "Maximum tokens to return (only for chunks/sections format)",
-                    default: 50000,
-                },
-                chunkSize: {
-                    type: "number",
-                    description: "Target size for each chunk in tokens (for chunks format)",
-                    default: 4000,
-                },
-                includeMetadata: {
-                    type: "boolean",
-                    description: "Include metadata about sections/chunks",
-                    default: true,
-                },
-                confirmLargeContent: {
-                    type: "boolean",
-                    description: "Confirm retrieval of large content (>10k tokens)",
-                    default: false,
-                },
-            },
-            required: ["contentId"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                contentId: z.string(),
-                format: z.enum(["full", "chunks", "sections"]).optional().default("chunks"),
-                maxTokens: z.number().optional().default(50000),
-                chunkSize: z.number().optional().default(4000),
-                includeMetadata: z.boolean().optional().default(true),
-                confirmLargeContent: z.boolean().optional().default(false),
-            });
-            const params = schema.parse(args);
-            // First get content metadata to check size
-            const content = await client.getContent(params.contentId);
-            if (!content.rawText) {
-                // Try to get raw content through v2 API with enrichment
-                const enrichedResult = await client.getEnrichedContent([params.contentId], true);
-                if (!enrichedResult || enrichedResult.length === 0 || !enrichedResult[0].rawText) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `No raw text available for content ID: ${params.contentId}. Content may still be processing or does not contain extractable text.`,
-                            },
-                        ],
-                        data: null,
-                    };
-                }
-                // Use the enriched content
-                content.rawText = enrichedResult[0].rawText;
-                content.tokenCount = enrichedResult[0].tokenCount;
-            }
-            const wordCount = content.rawText ? content.rawText.split(/\s+/).length : 0;
-            const estimatedTokens = content.tokenCount || Math.ceil(wordCount * 1.3);
-            // Check if confirmation is needed for large content
-            if (params.format === "full" && estimatedTokens > 10000 && !params.confirmLargeContent) {
-                let warningText = `# ⚠️ Large Content Warning\n\n`;
-                warningText += `**Content:** ${content.title || 'Untitled'}\n`;
-                warningText += `**Size:** ${wordCount.toLocaleString()} words (~${estimatedTokens.toLocaleString()} tokens)\n\n`;
-                if (estimatedTokens > 100000) {
-                    warningText += `## 🚨 CRITICAL: Extremely Large Content\n`;
-                    warningText += `This content contains ${estimatedTokens.toLocaleString()} tokens and will **exceed most LLM context windows**.\n\n`;
-                    warningText += `**Recommendations:**\n`;
-                    warningText += `1. Use format='chunks' to process in smaller pieces\n`;
-                    warningText += `2. Use format='sections' to get logical divisions\n`;
-                    warningText += `3. Use search_content to find specific information\n`;
-                    warningText += `4. Use synthesize_content to get key insights without full text\n\n`;
-                }
-                else if (estimatedTokens > 50000) {
-                    warningText += `## ⚠️ Very Large Content\n`;
-                    warningText += `This content contains ${estimatedTokens.toLocaleString()} tokens and will use **most of your context window**.\n\n`;
-                    warningText += `**Consider:**\n`;
-                    warningText += `- Using format='chunks' for manageable pieces\n`;
-                    warningText += `- Using search or synthesis tools instead\n\n`;
-                }
-                else {
-                    warningText += `## Large Content Notice\n`;
-                    warningText += `This content will use ${estimatedTokens.toLocaleString()} tokens of your context.\n\n`;
-                }
-                warningText += `**To proceed with full text retrieval:**\n`;
-                warningText += `Call get_raw_content again with:\n`;
-                warningText += `- contentId: "${params.contentId}"\n`;
-                warningText += `- format: "full"\n`;
-                warningText += `- confirmLargeContent: true\n\n`;
-                warningText += `**Alternative approaches:**\n`;
-                warningText += `- format: "chunks" - Get content in ${Math.ceil(estimatedTokens / params.chunkSize)} chunks of ~${params.chunkSize} tokens\n`;
-                warningText += `- format: "sections" - Get logical sections with headers\n`;
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: warningText,
-                        },
-                    ],
-                    data: {
-                        requiresConfirmation: true,
-                        contentId: params.contentId,
-                        title: content.title,
-                        estimatedTokens,
-                        suggestedFormat: estimatedTokens > 50000 ? "chunks" : "sections",
-                        chunkCount: Math.ceil(estimatedTokens / params.chunkSize),
-                    },
-                };
-            }
-            let responseText = `# Raw Content: ${content.title || 'Untitled'}\n\n`;
-            responseText += `**Content Type:** ${content.contentType}\n`;
-            responseText += `**URL:** ${content.url}\n`;
-            responseText += `**Size:** ${wordCount.toLocaleString()} words (~${estimatedTokens.toLocaleString()} tokens)\n`;
-            // Add appropriate warning based on size
-            if (estimatedTokens > 50000 && params.format === "full") {
-                responseText += `\n⚠️ **Large content confirmed** - Returning ${estimatedTokens.toLocaleString()} tokens\n\n`;
-            }
-            let resultData = {
-                id: content.id,
-                title: content.title,
-                contentType: content.contentType,
-                totalTokens: estimatedTokens,
-                format: params.format,
-            };
-            if (params.format === "full") {
-                // Return full text (with confirmation)
-                responseText += `\n## Full Text Content\n`;
-                responseText += `*Complete raw text (${estimatedTokens.toLocaleString()} tokens) is available in the data field.*\n`;
-                resultData.text = content.rawText;
-                resultData.metadata = params.includeMetadata ? {
-                    wordCount,
-                    estimatedTokens,
-                    contentType: content.contentType,
-                    extractedAt: content.createdAt,
-                } : undefined;
-            }
-            else if (params.format === "chunks") {
-                // Smart chunking based on token size
-                const chunks = chunkContent(content.rawText || "", params.chunkSize, params.maxTokens);
-                responseText += `\n## Content Chunks\n`;
-                responseText += `**Total Chunks:** ${chunks.length}\n`;
-                responseText += `**Chunk Size:** ~${params.chunkSize} tokens each\n`;
-                if (chunks.length * params.chunkSize > params.maxTokens) {
-                    responseText += `**Note:** Showing first ${chunks.length} chunks (limited by maxTokens: ${params.maxTokens})\n`;
-                }
-                responseText += `\n`;
-                // Show chunk previews
-                chunks.slice(0, 3).forEach((chunk, idx) => {
-                    responseText += `### Chunk ${idx + 1}/${chunks.length}\n`;
-                    responseText += `**Tokens:** ~${chunk.tokenCount}\n`;
-                    responseText += `**Preview:** ${chunk.text.slice(0, 200)}...\n\n`;
-                });
-                if (chunks.length > 3) {
-                    responseText += `*... and ${chunks.length - 3} more chunks*\n\n`;
-                }
-                responseText += `💡 **Tip:** To get a specific chunk, note the chunk index and request it directly.\n`;
-                resultData.chunks = chunks;
-                resultData.totalChunks = chunks.length;
-            }
-            else if (params.format === "sections") {
-                // Logical section detection (headers, paragraphs, etc.)
-                const sections = detectSections(content.rawText || "", content.contentType);
-                responseText += `\n## Content Sections\n`;
-                responseText += `**Total Sections:** ${sections.length}\n\n`;
-                // Show section outline
-                let totalSectionTokens = 0;
-                sections.forEach((section, idx) => {
-                    responseText += `${idx + 1}. **${section.title || `Section ${idx + 1}`}**`;
-                    if (section.type) {
-                        responseText += ` (${section.type})`;
-                    }
-                    responseText += ` - ~${section.tokenCount} tokens\n`;
-                    totalSectionTokens += section.tokenCount;
-                    if (totalSectionTokens > params.maxTokens) {
-                        responseText += `   *[Exceeds maxTokens limit]*\n`;
-                    }
-                });
-                responseText += `\n*Full section content available in data field*\n`;
-                resultData.sections = sections;
-                resultData.totalSections = sections.length;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: resultData,
-            };
-        },
-    },
-    {
-        name: "explore_topic",
-        description: "Deep exploration of a topic across all saved content. Provides comprehensive understanding with multiple perspectives, evolution over time, and key concepts.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: {
-                    type: "string",
-                    description: "The topic to explore comprehensively",
-                },
-                depth: {
-                    type: "string",
-                    enum: ["surface", "comprehensive", "expert"],
-                    description: "Depth of exploration",
-                    default: "comprehensive",
-                },
-                includeTimeline: {
-                    type: "boolean",
-                    description: "Include chronological evolution of the topic",
-                    default: true,
-                },
-                includeConnections: {
-                    type: "boolean",
-                    description: "Find connections to related topics",
-                    default: true,
-                },
-                maxSources: {
-                    type: "number",
-                    description: "Maximum number of sources to analyze",
-                    default: 20,
-                },
-            },
-            required: ["topic"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                topic: z.string(),
-                depth: z.enum(["surface", "comprehensive", "expert"]).optional().default("comprehensive"),
-                includeTimeline: z.boolean().optional().default(true),
-                includeConnections: z.boolean().optional().default(true),
-                maxSources: z.number().optional().default(20),
-            });
-            const params = schema.parse(args);
-            // Search for all content related to the topic
-            const searchResults = await client.searchContent(params.topic, {
-                limit: params.maxSources,
-                enableConceptExpansion: true,
-                fuzzyMatch: true,
-            });
-            if (!searchResults || searchResults.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No content found for topic: "${params.topic}". Try saving relevant content first or use a different search term.`,
-                        },
-                    ],
-                    data: null,
-                };
-            }
-            // Synthesize the content for deep understanding
-            const synthesis = await client.synthesizeContent({
-                query: `Comprehensive exploration of ${params.topic}`,
-                contentIds: searchResults.slice(0, params.maxSources).map((r) => r.id),
-                synthesisMode: params.depth === "expert" ? "deep" : params.depth === "surface" ? "overview" : "actionable",
-                findConnections: params.includeConnections,
-                findContradictions: true,
-            });
-            let responseText = `# 🔍 Topic Exploration: "${params.topic}"\n`;
-            responseText += `**Depth:** ${params.depth} | **Sources Analyzed:** ${searchResults.length}\n\n`;
-            // Overview Section
-            responseText += `## 📋 Overview\n`;
-            if (synthesis.synthesis?.summary) {
-                responseText += `${synthesis.synthesis.summary}\n\n`;
-            }
-            else {
-                responseText += `Analysis of ${searchResults.length} pieces of content about ${params.topic}.\n\n`;
-            }
-            // Key Concepts
-            responseText += `## 🎯 Key Concepts\n`;
-            const concepts = extractKeyConceptsFromSearch(searchResults, params.topic);
-            concepts.slice(0, 10).forEach((concept, idx) => {
-                responseText += `${idx + 1}. ${concept}\n`;
-            });
-            responseText += `\n`;
-            // Multiple Perspectives
-            responseText += `## 👥 Different Perspectives\n`;
-            const perspectives = groupByPerspective(searchResults);
-            Object.entries(perspectives).slice(0, 5).forEach(([perspective, items]) => {
-                responseText += `\n### ${perspective}\n`;
-                responseText += `*Found in ${items.length} sources*\n`;
-                if (items[0]?.summary) {
-                    const summary = typeof items[0].summary === 'string' ? items[0].summary : items[0].summary.one_sentence;
-                    responseText += `Example: "${summary?.slice(0, 200)}..."\n`;
-                }
-            });
-            responseText += `\n`;
-            // Timeline (if requested)
-            if (params.includeTimeline && searchResults.length > 1) {
-                responseText += `## ⏱️ Topic Evolution\n`;
-                const timeline = createTopicTimeline(searchResults);
-                timeline.forEach((event) => {
-                    responseText += `- **${event.date}:** ${event.title} - ${event.insight}\n`;
-                });
-                responseText += `\n`;
-            }
-            // Connections (if found)
-            if (params.includeConnections && synthesis.synthesis?.connections) {
-                responseText += `## 🔗 Related Topics & Connections\n`;
-                synthesis.synthesis.connections.slice(0, 8).forEach((conn) => {
-                    if (typeof conn === 'string') {
-                        responseText += `- ${conn}\n`;
-                    }
-                    else if (conn.concept) {
-                        responseText += `- **${conn.concept}**`;
-                        if (conn.strength) {
-                            responseText += ` (strength: ${conn.strength})`;
-                        }
-                        responseText += `\n`;
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Contradictions & Debates
-            if (synthesis.synthesis?.contradictions && synthesis.synthesis.contradictions.length > 0) {
-                responseText += `## ⚡ Contradictions & Debates\n`;
-                synthesis.synthesis.contradictions.slice(0, 3).forEach((contra) => {
-                    responseText += `\n**Point of Contention:**\n`;
-                    if (contra.topic) {
-                        responseText += `${contra.topic}\n`;
-                    }
-                    if (contra.viewpoints) {
-                        contra.viewpoints.forEach((vp) => {
-                            responseText += `- ${vp.position}: ${vp.argument}\n`;
-                        });
-                    }
-                });
-                responseText += `\n`;
-            }
-            // Learning Path (for comprehensive/expert depth)
-            if (params.depth !== "surface") {
-                responseText += `## 📚 Suggested Learning Path\n`;
-                const learningPath = createLearningPath(searchResults, params.topic);
-                learningPath.forEach((step, idx) => {
-                    responseText += `${idx + 1}. **${step.title}** - ${step.reason}\n`;
-                });
-                responseText += `\n`;
-            }
-            // Expert Insights (for expert depth)
-            if (params.depth === "expert" && synthesis.synthesis?.insights) {
-                responseText += `## 💡 Expert-Level Insights\n`;
-                synthesis.synthesis.insights.slice(0, 5).forEach((insight, idx) => {
-                    const text = typeof insight === 'string' ? insight : insight.text;
-                    responseText += `${idx + 1}. ${text}\n`;
-                });
-                responseText += `\n`;
-            }
-            // Sources
-            responseText += `## 📚 Top Sources\n`;
-            searchResults.slice(0, 5).forEach((source, idx) => {
-                const typeIcons = {
-                    youtube: "📺",
-                    x_twitter: "𝕏",
-                    reddit: "🔗",
-                    article: "📄",
-                    pdf: "📑"
-                };
-                const icon = typeIcons[source.contentType] || "📄";
-                responseText += `${idx + 1}. ${icon} [${source.title || "Untitled"}](${source.url})\n`;
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: {
-                    topic: params.topic,
-                    depth: params.depth,
-                    sourcesAnalyzed: searchResults.length,
-                    synthesis: synthesis.synthesis,
-                    sources: searchResults,
-                    concepts,
-                    perspectives,
-                },
-            };
-        },
-    },
-    {
-        name: "find_connections",
-        description: "Discover connections and relationships between different pieces of content. Identifies causal links, contradictions, and complementary information.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                contentIds: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "Array of content IDs to find connections between",
-                },
-                connectionType: {
-                    type: "string",
-                    enum: ["all", "causal", "contradictory", "complementary", "sequential"],
-                    description: "Type of connections to find",
-                    default: "all",
-                },
-                depth: {
-                    type: "number",
-                    description: "How many levels deep to search for connections (1-3)",
-                    default: 1,
-                },
-            },
-            required: ["contentIds"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                contentIds: z.array(z.string()).min(2),
-                connectionType: z.enum(["all", "causal", "contradictory", "complementary", "sequential"]).optional().default("all"),
-                depth: z.number().min(1).max(3).optional().default(1),
-            });
-            const params = schema.parse(args);
-            // Fetch all content items
-            const contents = await client.batchGetContent(params.contentIds, false);
-            if (!contents.results || contents.results.length < 2) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Unable to find connections. Need at least 2 valid content items.",
-                        },
-                    ],
-                    data: null,
-                };
-            }
-            // Analyze connections between content
-            const connections = analyzeConnections(contents.results, params.connectionType);
-            let responseText = `# 🔗 Content Connections Analysis\n`;
-            responseText += `**Analyzing:** ${contents.results.length} pieces of content\n`;
-            responseText += `**Connection Type:** ${params.connectionType}\n`;
-            responseText += `**Connections Found:** ${connections.length}\n\n`;
-            if (connections.length === 0) {
-                responseText += `No ${params.connectionType} connections found between the provided content.\n`;
-                responseText += `Try using connectionType='all' for broader analysis.\n`;
-            }
-            else {
-                // Group connections by type
-                const byType = groupConnectionsByType(connections);
-                Object.entries(byType).forEach(([type, conns]) => {
-                    responseText += `## ${getConnectionTypeEmoji(type)} ${type} Connections (${conns.length})\n\n`;
-                    conns.slice(0, 5).forEach((conn) => {
-                        responseText += `### ${conn.source1.title} ↔️ ${conn.source2.title}\n`;
-                        responseText += `**Relationship:** ${conn.relationship}\n`;
-                        responseText += `**Strength:** ${getStrengthIndicator(conn.strength)}\n`;
-                        if (conn.explanation) {
-                            responseText += `**Why:** ${conn.explanation}\n`;
-                        }
-                        if (conn.sharedConcepts && conn.sharedConcepts.length > 0) {
-                            responseText += `**Shared Concepts:** ${conn.sharedConcepts.join(', ')}\n`;
-                        }
-                        responseText += `\n`;
-                    });
-                });
-                // Network summary
-                responseText += `## 🌐 Connection Network Summary\n`;
-                const networkStats = calculateNetworkStats(connections, contents.results);
-                responseText += `- **Most Connected:** ${networkStats.mostConnected.title} (${networkStats.mostConnected.connectionCount} connections)\n`;
-                responseText += `- **Central Theme:** ${networkStats.centralTheme}\n`;
-                responseText += `- **Network Density:** ${networkStats.density}\n`;
-                if (params.depth > 1) {
-                    responseText += `\n## 🔍 Extended Connections (Depth ${params.depth})\n`;
-                    responseText += `*Searching for indirect connections through related content...*\n`;
-                    // This would require additional searches for related content
-                    responseText += `Use find_similar_content on highly connected items to explore further.\n`;
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: {
-                    connections,
-                    contents: contents.results,
-                    networkStats: connections.length > 0 ? calculateNetworkStats(connections, contents.results) : null,
-                },
-            };
-        },
-    },
-    {
-        name: "extract_insights",
-        description: "Extract specific types of insights across multiple content sources. Finds patterns, contradictions, consensus, or evolution of ideas.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "What insights to extract (e.g., 'productivity tips', 'AI risks', 'investment strategies')",
-                },
-                insightType: {
-                    type: "string",
-                    enum: ["patterns", "contradictions", "consensus", "evolution", "actionable", "warnings"],
-                    description: "Type of insights to extract",
-                    default: "patterns",
-                },
-                maxSources: {
-                    type: "number",
-                    description: "Maximum number of sources to analyze",
-                    default: 15,
-                },
-                minConfidence: {
-                    type: "number",
-                    description: "Minimum confidence score for insights (0-1)",
-                    default: 0.7,
-                },
-            },
-            required: ["query"],
-        },
-        modifies: false,
-        handler: async (client, args) => {
-            const schema = z.object({
-                query: z.string(),
-                insightType: z.enum(["patterns", "contradictions", "consensus", "evolution", "actionable", "warnings"]).optional().default("patterns"),
-                maxSources: z.number().optional().default(15),
-                minConfidence: z.number().min(0).max(1).optional().default(0.7),
-            });
-            const params = schema.parse(args);
-            // Search for relevant content
-            const searchResults = await client.searchContent(params.query, {
-                limit: params.maxSources,
-                enableConceptExpansion: true,
-            });
-            if (!searchResults || searchResults.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No content found for extracting insights about: "${params.query}"`,
-                        },
-                    ],
-                    data: null,
-                };
-            }
-            // Extract insights based on type
-            const insights = extractTypedInsights(searchResults, params.query, params.insightType, params.minConfidence);
-            let responseText = `# 💡 Insight Extraction: "${params.query}"\n`;
-            responseText += `**Type:** ${params.insightType} | **Sources:** ${searchResults.length} | **Min Confidence:** ${(params.minConfidence * 100).toFixed(0)}%\n\n`;
-            if (insights.length === 0) {
-                responseText += `No ${params.insightType} insights found with confidence >= ${params.minConfidence}.\n`;
-                responseText += `Try lowering the confidence threshold or using a different insight type.\n`;
-            }
-            else {
-                // Display insights by type
-                switch (params.insightType) {
-                    case "patterns":
-                        responseText += `## 🔄 Recurring Patterns\n\n`;
-                        insights.forEach((insight, idx) => {
-                            responseText += `### Pattern ${idx + 1}: ${insight.pattern}\n`;
-                            responseText += `**Frequency:** Appears in ${insight.frequency}/${searchResults.length} sources\n`;
-                            responseText += `**Confidence:** ${(insight.confidence * 100).toFixed(0)}%\n`;
-                            responseText += `**Examples:**\n`;
-                            insight.examples.slice(0, 3).forEach((ex) => {
-                                responseText += `- "${ex.text}" *(${ex.source})*\n`;
-                            });
-                            responseText += `\n`;
-                        });
-                        break;
-                    case "contradictions":
-                        responseText += `## ⚡ Contradictions & Disagreements\n\n`;
-                        insights.forEach((insight, idx) => {
-                            responseText += `### Contradiction ${idx + 1}: ${insight.topic}\n`;
-                            responseText += `**Position A:** "${insight.position1.statement}"\n`;
-                            responseText += `*Sources:* ${insight.position1.sources.join(', ')}\n\n`;
-                            responseText += `**Position B:** "${insight.position2.statement}"\n`;
-                            responseText += `*Sources:* ${insight.position2.sources.join(', ')}\n`;
-                            if (insight.resolution) {
-                                responseText += `\n**Possible Resolution:** ${insight.resolution}\n`;
-                            }
-                            responseText += `\n`;
-                        });
-                        break;
-                    case "consensus":
-                        responseText += `## ✅ Points of Consensus\n\n`;
-                        insights.forEach((insight, idx) => {
-                            responseText += `${idx + 1}. **${insight.point}**\n`;
-                            responseText += `   - Agreement: ${insight.agreementLevel}% of sources\n`;
-                            responseText += `   - Confidence: ${(insight.confidence * 100).toFixed(0)}%\n`;
-                            if (insight.nuances && insight.nuances.length > 0) {
-                                responseText += `   - Nuances: ${insight.nuances.join('; ')}\n`;
-                            }
-                        });
-                        responseText += `\n`;
-                        break;
-                    case "evolution":
-                        responseText += `## 📈 Evolution of Ideas\n\n`;
-                        insights.forEach((insight, idx) => {
-                            responseText += `### ${insight.concept}\n`;
-                            responseText += `**Timeline:**\n`;
-                            insight.timeline.forEach((point) => {
-                                responseText += `- **${point.date}:** ${point.understanding}\n`;
-                            });
-                            responseText += `**Current State:** ${insight.currentState}\n`;
-                            responseText += `**Trend:** ${insight.trend}\n\n`;
-                        });
-                        break;
-                    case "actionable":
-                        responseText += `## 🎯 Actionable Insights\n\n`;
-                        insights.forEach((insight, idx) => {
-                            responseText += `### ${idx + 1}. ${insight.action}\n`;
-                            responseText += `**Why:** ${insight.reasoning}\n`;
-                            responseText += `**Priority:** ${insight.priority}\n`;
-                            responseText += `**Evidence from:** ${insight.sources.length} sources\n`;
-                            if (insight.steps && insight.steps.length > 0) {
-                                responseText += `**Steps:**\n`;
-                                insight.steps.forEach((step, i) => {
-                                    responseText += `${i + 1}. ${step}\n`;
-                                });
-                            }
-                            responseText += `\n`;
-                        });
-                        break;
-                    case "warnings":
-                        responseText += `## ⚠️ Warnings & Risks\n\n`;
-                        insights.forEach((insight, idx) => {
-                            const severityEmoji = insight.severity === "high" ? "🔴" : insight.severity === "medium" ? "🟡" : "🟢";
-                            responseText += `### ${severityEmoji} ${insight.warning}\n`;
-                            responseText += `**Severity:** ${insight.severity}\n`;
-                            responseText += `**Mentioned in:** ${insight.sources.length} sources\n`;
-                            responseText += `**Context:** ${insight.context}\n`;
-                            if (insight.mitigation) {
-                                responseText += `**Mitigation:** ${insight.mitigation}\n`;
-                            }
-                            responseText += `\n`;
-                        });
-                        break;
-                }
-                // Summary statistics
-                responseText += `## 📊 Extraction Summary\n`;
-                responseText += `- **Total Insights:** ${insights.length}\n`;
-                responseText += `- **Average Confidence:** ${(insights.reduce((sum, i) => sum + i.confidence, 0) / insights.length * 100).toFixed(0)}%\n`;
-                responseText += `- **Sources Analyzed:** ${searchResults.length}\n`;
-                const contributingSources = new Set(insights.flatMap((i) => i.sources || []));
-                responseText += `- **Contributing Sources:** ${contributingSources.size}\n`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: responseText,
-                    },
-                ],
-                data: {
-                    query: params.query,
-                    insightType: params.insightType,
-                    insights,
-                    sources: searchResults,
-                },
-            };
-        },
-    },
-];
-// Helper functions for the new tools
-function chunkContent(text, targetTokenSize, maxTokens) {
-    const words = text.split(/\s+/);
-    const wordsPerChunk = Math.floor(targetTokenSize / 1.3); // Rough token estimation
-    const chunks = [];
-    let totalTokens = 0;
-    for (let i = 0; i < words.length; i += wordsPerChunk) {
-        const chunkWords = words.slice(i, i + wordsPerChunk);
-        const chunkText = chunkWords.join(' ');
-        const chunkTokens = Math.ceil(chunkWords.length * 1.3);
-        // Stop if we've reached the max token limit
-        if (maxTokens && totalTokens + chunkTokens > maxTokens) {
-            break;
-        }
-        chunks.push({
-            index: chunks.length,
-            text: chunkText,
-            tokenCount: chunkTokens,
-            startOffset: i,
-            endOffset: Math.min(i + wordsPerChunk, words.length),
-        });
-        totalTokens += chunkTokens;
-    }
-    return chunks;
-}
-function detectSections(text, contentType) {
-    const sections = [];
-    // Simple section detection based on headers and paragraphs
-    const lines = text.split('\n');
-    let currentSection = { title: "Introduction", text: "", type: "intro", tokenCount: 0 };
-    for (const line of lines) {
-        // Detect headers (various formats)
-        if (line.match(/^#{1,6}\s+/) || line.match(/^[A-Z][^.!?]*:$/) || (line.length < 100 && line.match(/^[A-Z]/))) {
-            if (currentSection.text) {
-                currentSection.tokenCount = Math.ceil(currentSection.text.split(/\s+/).length * 1.3);
-                sections.push(currentSection);
-            }
-            currentSection = {
-                title: line.replace(/^#+\s+/, '').replace(/:$/, ''),
-                text: "",
-                type: "section",
-                tokenCount: 0,
-            };
-        }
-        else {
-            currentSection.text += line + "\n";
-        }
-    }
-    // Add the last section
-    if (currentSection.text) {
-        currentSection.tokenCount = Math.ceil(currentSection.text.split(/\s+/).length * 1.3);
-        sections.push(currentSection);
-    }
-    return sections;
-}
-function extractKeyConceptsFromSearch(results, topic) {
-    const concepts = new Map();
-    results.forEach(result => {
-        // Extract from tags
-        if (result.tags) {
-            result.tags.forEach((tag) => {
-                concepts.set(tag, (concepts.get(tag) || 0) + 2);
-            });
-        }
-        // Extract from summary
-        if (result.summary) {
-            const summary = typeof result.summary === 'string' ? result.summary : result.summary.one_sentence;
-            if (summary) {
-                // Simple concept extraction from summary
-                const words = summary.toLowerCase().split(/\s+/);
-                const importantWords = words.filter((w) => w.length > 5 && !['about', 'through', 'between', 'during'].includes(w));
-                importantWords.forEach((word) => {
-                    concepts.set(word, (concepts.get(word) || 0) + 1);
-                });
-            }
-        }
-    });
-    // Sort by frequency and return top concepts
-    return Array.from(concepts.entries())
-        .sort((a, b) => b[1] - a[1])
-        .map(([concept]) => concept)
-        .filter(concept => concept.toLowerCase() !== topic.toLowerCase());
-}
-function groupByPerspective(results) {
-    const perspectives = {};
-    results.forEach(result => {
-        // Group by content type as a simple perspective grouping
-        const perspective = result.contentType || 'general';
-        if (!perspectives[perspective]) {
-            perspectives[perspective] = [];
-        }
-        perspectives[perspective].push(result);
-    });
-    return perspectives;
-}
-function createTopicTimeline(results) {
-    // Sort by date and create timeline
-    const sorted = results
-        .filter(r => r.createdAt)
-        .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-    return sorted.slice(0, 5).map(result => ({
-        date: new Date(result.createdAt).toLocaleDateString(),
-        title: result.title || "Untitled",
-        insight: typeof result.summary === 'string'
-            ? result.summary.slice(0, 100)
-            : result.summary?.one_sentence?.slice(0, 100) || "No summary",
-    }));
-}
-function createLearningPath(results, topic) {
-    // Create a simple learning path based on content
-    const path = [];
-    // Find introductory content
-    const intro = results.find(r => r.title?.toLowerCase().includes('introduction') ||
-        r.title?.toLowerCase().includes('basics') ||
-        r.title?.toLowerCase().includes('beginner'));
-    if (intro) {
-        path.push({
-            title: intro.title || "Introduction",
-            reason: "Start with foundational concepts",
-            id: intro.id,
-        });
-    }
-    // Add the most relevant content
-    results
-        .filter(r => r.id !== intro?.id)
-        .slice(0, 3)
-        .forEach(result => {
-        path.push({
-            title: result.title || "Untitled",
-            reason: "Build on core concepts",
-            id: result.id,
-        });
-    });
-    return path;
-}
-function analyzeConnections(contents, connectionType) {
-    const connections = [];
-    // Analyze pairs of content
-    for (let i = 0; i < contents.length; i++) {
-        for (let j = i + 1; j < contents.length; j++) {
-            const conn = findConnection(contents[i], contents[j], connectionType);
-            if (conn) {
-                connections.push(conn);
-            }
-        }
-    }
-    return connections;
-}
-function findConnection(content1, content2, type) {
-    // Simple connection detection based on shared concepts
-    const tags1 = new Set(content1.tags || []);
-    const tags2 = new Set(content2.tags || []);
-    const sharedTags = Array.from(tags1).filter(t => tags2.has(t));
-    if (sharedTags.length === 0 && type !== "contradictory") {
-        return null;
-    }
-    return {
-        source1: { id: content1.id, title: content1.title || "Untitled" },
-        source2: { id: content2.id, title: content2.title || "Untitled" },
-        type: sharedTags.length > 2 ? "strong" : "weak",
-        relationship: sharedTags.length > 0 ? "complementary" : "independent",
-        strength: sharedTags.length / Math.max(tags1.size, tags2.size),
-        sharedConcepts: sharedTags,
-        explanation: `Share ${sharedTags.length} common concepts`,
-    };
-}
-function groupConnectionsByType(connections) {
-    const grouped = {};
-    connections.forEach(conn => {
-        const type = conn.relationship || "unknown";
-        if (!grouped[type]) {
-            grouped[type] = [];
-        }
-        grouped[type].push(conn);
-    });
-    return grouped;
-}
-function getConnectionTypeEmoji(type) {
-    const emojis = {
-        complementary: "🤝",
-        contradictory: "⚡",
-        causal: "➡️",
-        sequential: "📅",
-        independent: "🔀",
-    };
-    return emojis[type] || "🔗";
-}
-function getStrengthIndicator(strength) {
-    if (strength > 0.8)
-        return "🟢🟢🟢 Very Strong";
-    if (strength > 0.6)
-        return "🟢🟢 Strong";
-    if (strength > 0.4)
-        return "🟡 Moderate";
-    if (strength > 0.2)
-        return "🟠 Weak";
-    return "🔴 Very Weak";
-}
-function calculateNetworkStats(connections, contents) {
-    const connectionCounts = new Map();
-    connections.forEach(conn => {
-        const id1 = conn.source1.id;
-        const id2 = conn.source2.id;
-        connectionCounts.set(id1, (connectionCounts.get(id1) || 0) + 1);
-        connectionCounts.set(id2, (connectionCounts.get(id2) || 0) + 1);
-    });
-    const mostConnectedId = Array.from(connectionCounts.entries())
-        .sort((a, b) => b[1] - a[1])[0]?.[0];
-    const mostConnected = contents.find(c => c.id === mostConnectedId) || contents[0];
-    return {
-        mostConnected: {
-            title: mostConnected?.title || "Unknown",
-            connectionCount: connectionCounts.get(mostConnectedId) || 0,
-        },
-        centralTheme: connections[0]?.sharedConcepts?.[0] || "Unknown",
-        density: connections.length > 0 ? "High" : "Low",
-    };
-}
-function extractTypedInsights(results, query, type, minConfidence) {
-    // Simplified insight extraction
-    const insights = [];
-    switch (type) {
-        case "patterns":
-            // Find recurring themes
-            const themes = new Map();
-            results.forEach(result => {
-                if (result.tags) {
-                    result.tags.forEach((tag) => {
-                        if (!themes.has(tag))
-                            themes.set(tag, []);
-                        themes.get(tag).push(result);
-                    });
-                }
-            });
-            Array.from(themes.entries())
-                .filter(([_, sources]) => sources.length >= 2)
-                .forEach(([theme, sources]) => {
-                insights.push({
-                    pattern: theme,
-                    frequency: sources.length,
-                    confidence: sources.length / results.length,
-                    examples: sources.slice(0, 3).map(s => ({
-                        text: s.title || "Untitled",
-                        source: s.contentType,
-                    })),
-                });
-            });
-            break;
-        case "actionable":
-            // Extract actionable items from summaries
-            results.forEach(result => {
-                if (result.summary && typeof result.summary === 'object' && result.summary.actionable_takeaways) {
-                    result.summary.actionable_takeaways.forEach((action) => {
-                        insights.push({
-                            action,
-                            reasoning: "Extracted from content analysis",
-                            priority: "medium",
-                            sources: [result],
-                            confidence: 0.8,
-                        });
-                    });
-                }
-            });
-            break;
-        default:
-            // Generic insight extraction
-            results.slice(0, 5).forEach(result => {
-                if (result.summary) {
-                    insights.push({
-                        text: typeof result.summary === 'string' ? result.summary : result.summary.one_sentence,
-                        source: result.title || "Untitled",
-                        confidence: 0.75,
-                    });
-                }
-            });
-    }
-    return insights.filter((i) => i.confidence >= minConfidence);
-}
-//# sourceMappingURL=index-old.js.map