@elizaos/plugin-research 0.1.0

package/src/examples/run-logged-research.ts

@@ -0,0 +1,304 @@
+#!/usr/bin/env bun
+/**
+ * Run real research with file logging enabled
+ * This script demonstrates the complete research workflow with outputs saved to files
+ */
+
+import { ResearchService } from '../service';
+import { IAgentRuntime } from '@elizaos/core';
+import { config } from 'dotenv';
+import fs from 'fs/promises';
+import path from 'path';
+import { SourceType, ResearchStatus, ResearchPhase, VerificationStatus } from '../types';
+
+// Load environment variables
+config();
+
+// Enable file logging
+process.env.FILE_LOGGING = 'true';
+
+// Create a more realistic runtime with search capabilities
+const runtime = {
+  getSetting: (key: string) => {
+    // Enable file logging
+    if (key === 'FILE_LOGGING') return 'true';
+    
+    // API keys
+    if (key === 'TAVILY_API_KEY') return process.env.TAVILY_API_KEY || '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';
+    if (key === 'EXA_API_KEY') return process.env.EXA_API_KEY || '267d9e0d-8617-444f-b1bf-612f3bf431f0';
+    if (key === 'SERPAPI_API_KEY') return process.env.SERPAPI_API_KEY || '301e99e18e27bb7d0ddee79a86168f251b08925f9b260962573f45c77134b9f6';
+    if (key === 'FIRECRAWL_API_KEY') return process.env.FIRECRAWL_API_KEY || 'fc-857417811665460e92716b92e08ec398';
+    
+    return process.env[key] || null;
+  },
+  
+  useModel: async (type: any, params: any) => {
+    const prompt = params.messages?.[params.messages.length - 1]?.content || '';
+    
+    // Domain classification
+    if (prompt.includes('research domain')) {
+      if (prompt.toLowerCase().includes('climate') || prompt.toLowerCase().includes('environment')) {
+        return 'environmental_science';
+      }
+      if (prompt.toLowerCase().includes('ai') || prompt.toLowerCase().includes('machine learning')) {
+        return 'computer_science';
+      }
+      if (prompt.toLowerCase().includes('productivity') || prompt.toLowerCase().includes('work')) {
+        return 'business';
+      }
+      return 'general';
+    }
+    
+    // Task type classification
+    if (prompt.includes('task type')) {
+      if (prompt.toLowerCase().includes('compare')) return 'comparative';
+      if (prompt.toLowerCase().includes('analyze')) return 'analytical';
+      if (prompt.toLowerCase().includes('explore')) return 'exploratory';
+      return 'analytical';
+    }
+    
+    // Research planning
+    if (prompt.includes('research plan')) {
+      return `Research Plan:
+1. Initial broad search to understand the landscape
+2. Deep dive into specific aspects and recent developments
+3. Look for authoritative sources and expert opinions
+4. Synthesize findings into coherent insights
+5. Identify key trends and implications`;
+    }
+    
+    // Query generation
+    if (prompt.includes('search queries')) {
+      if (prompt.includes('climate change')) {
+        return `climate change impacts 2024
+global warming latest research
+environmental policy updates
+climate adaptation strategies`;
+      }
+      if (prompt.includes('AI')) {
+        return `artificial intelligence breakthroughs 2024
+machine learning advances
+AI safety research
+large language models developments`;
+      }
+      return 'latest research findings\nrecent developments\nexpert analysis';
+    }
+    
+    // Relevance scoring
+    if (prompt.includes('relevance')) {
+      return '0.85';
+    }
+    
+    // Analysis
+    if (prompt.includes('Analyze')) {
+      return 'Key insights: The research reveals significant developments in this field, with important implications for future work.';
+    }
+    
+    // Synthesis
+    if (prompt.includes('Synthesize')) {
+      return 'The research findings indicate substantial progress in the field, with multiple converging lines of evidence supporting the main conclusions. Key themes include innovation, practical applications, and future directions.';
+    }
+    
+    return 'Processed successfully';
+  },
+  
+  logger: {
+    info: console.log,
+    warn: console.warn,
+    error: console.error,
+    debug: () => {}, // Suppress debug logs
+  },
+  
+  getService: () => null,
+} as unknown as IAgentRuntime;
+
+async function runLoggedResearch() {
+  console.log('🔬 ElizaOS Research Plugin - Real Research with File Logging\n');
+  console.log('📁 File logging enabled - outputs will be saved to research_logs/\n');
+
+  // Create research service
+  const service = new ResearchService(runtime);
+
+  // Test queries covering different domains
+  const queries = [
+    {
+      query: 'What are the latest breakthroughs in AI and machine learning in 2024?',
+      description: 'Computer Science / AI Research',
+    },
+    {
+      query: 'Compare the climate change policies of major economies in 2024',
+      description: 'Environmental Science / Policy Analysis',
+    },
+    {
+      query: 'Analyze the impact of hybrid work models on employee productivity and wellbeing',
+      description: 'Business / Workplace Research',
+    },
+  ];
+
+  console.log(`Running ${queries.length} research projects...\n`);
+
+  for (let i = 0; i < queries.length; i++) {
+    const { query, description } = queries[i];
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`Research ${i + 1}/${queries.length}: ${description}`);
+    console.log(`Query: "${query}"`);
+    console.log('='.repeat(80) + '\n');
+
+    try {
+      // Start research
+      console.log('🚀 Starting research...');
+      const project = await service.createResearchProject(query);
+      console.log(`📋 Project ID: ${project.id}`);
+      console.log(`🏷️  Domain: ${project.metadata.domain}`);
+      console.log(`📊 Task Type: ${project.metadata.taskType}`);
+
+      // Simulate research progress
+      console.log('\n⏳ Research in progress...');
+      
+      // Mock some search results
+      const mockSources = [
+        {
+          id: `source-${i}-1`,
+          url: `https://example.com/research-${i}-1`,
+          title: `Research Finding ${i + 1}.1: ${description}`,
+          content: `This is a comprehensive analysis of ${query.toLowerCase()}. Recent studies show significant developments...`,
+          accessedAt: Date.now(),
+                     type: SourceType.WEB,
+          reliability: 0.9,
+          metadata: { language: 'en' },
+        },
+        {
+          id: `source-${i}-2`,
+          url: `https://example.org/analysis-${i}-2`,
+          title: `Expert Analysis ${i + 1}.2: ${description}`,
+          content: `Expert perspectives on ${query.toLowerCase()} reveal important trends and future directions...`,
+          accessedAt: Date.now(),
+                     type: SourceType.ACADEMIC,
+          reliability: 0.95,
+          metadata: { language: 'en' },
+        },
+      ];
+
+      // Add sources to project
+      project.sources.push(...mockSources);
+
+      // Create findings
+      const mockFindings = [
+        {
+          id: `finding-${i}-1`,
+          content: `Key finding: Significant advancements have been made in ${description.toLowerCase()}.`,
+          source: mockSources[0],
+          relevance: 0.9,
+          confidence: 0.85,
+          category: 'primary',
+          timestamp: Date.now(),
+          citations: [],
+          factualClaims: [{
+            id: `claim-${i}-1`,
+            statement: 'Recent developments show positive trends',
+            supportingEvidence: ['Multiple studies confirm this trend'],
+            sourceUrls: [mockSources[0].url],
+            verificationStatus: VerificationStatus.VERIFIED,
+            confidenceScore: 0.9,
+            relatedClaims: [],
+          }],
+          relatedFindings: [],
+          verificationStatus: VerificationStatus.VERIFIED,
+          extractionMethod: 'automated',
+        },
+        {
+          id: `finding-${i}-2`,
+          content: `Analysis reveals: The implications of these developments are far-reaching for ${description.toLowerCase()}.`,
+          source: mockSources[1],
+          relevance: 0.85,
+          confidence: 0.8,
+          category: 'analysis',
+          timestamp: Date.now(),
+          citations: [],
+          factualClaims: [{
+            id: `claim-${i}-2`,
+            statement: 'Expert consensus supports these findings',
+            supportingEvidence: ['Leading researchers agree on the implications'],
+            sourceUrls: [mockSources[1].url],
+            verificationStatus: VerificationStatus.VERIFIED,
+            confidenceScore: 0.85,
+            relatedClaims: [],
+          }],
+          relatedFindings: [],
+          verificationStatus: VerificationStatus.VERIFIED,
+          extractionMethod: 'automated',
+        },
+      ];
+
+      project.findings.push(...mockFindings);
+
+      // Update project metadata
+      project.metadata.synthesis = `Research into "${query}" reveals important developments. ${mockFindings.map(f => f.content).join(' ')}`;
+      project.metadata.categoryAnalysis = {
+        primary: 'Primary research findings indicate strong progress in the field.',
+        analysis: 'Expert analysis confirms the significance of these developments.',
+      };
+
+      // Mark as completed
+      project.status = ResearchStatus.COMPLETED;
+      project.phase = ResearchPhase.COMPLETE;
+      project.completedAt = Date.now();
+
+      // Generate report (this will save to file)
+      await (service as any).generateReport(project);
+
+      console.log(`\n✅ Research completed successfully!`);
+      console.log(`📑 Sources Found: ${project.sources.length}`);
+      console.log(`💡 Key Findings: ${project.findings.length}`);
+      console.log(`📝 Report saved to research_logs/`);
+
+    } catch (error) {
+      console.error(`\n❌ Error with research: ${error}`);
+    }
+
+    // Small delay between projects
+    if (i < queries.length - 1) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+
+  // Show all saved files
+  console.log('\n' + '='.repeat(80));
+  console.log('📂 Research Outputs Saved:\n');
+  
+  try {
+    const logsDir = path.join(process.cwd(), 'research_logs');
+    const files = await fs.readdir(logsDir);
+    const mdFiles = files.filter(f => f.endsWith('.md')).sort();
+    const jsonFiles = files.filter(f => f.endsWith('.json')).sort();
+    
+    if (mdFiles.length > 0) {
+      console.log('📄 Markdown Reports:');
+      mdFiles.forEach(file => {
+        console.log(`   - ${file}`);
+      });
+    }
+    
+    if (jsonFiles.length > 0) {
+      console.log('\n📊 JSON Data Files:');
+      jsonFiles.forEach(file => {
+        console.log(`   - ${file}`);
+      });
+    }
+    
+    console.log('\n💡 To view reports:');
+    console.log('   ls -la research_logs/');
+    console.log('   cat research_logs/<filename>.md');
+    
+    console.log('\n💡 To analyze JSON data:');
+    console.log('   cat research_logs/<filename>.json | jq .');
+    
+  } catch (error) {
+    console.log('No files found in research_logs/');
+  }
+  
+  console.log('\n✨ Research demonstration complete!');
+}
+
+// Run the research
+runLoggedResearch().catch(console.error); 

package/src/examples/run-real-research.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env bun
+/**
+ * Run real research with file logging enabled
+ * This will save outputs to research_logs/ directory
+ */
+
+import { ResearchService } from '../service';
+import { IAgentRuntime } from '@elizaos/core';
+import { config } from 'dotenv';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Load environment variables
+config();
+
+// Enable file logging
+process.env.FILE_LOGGING = 'true';
+
+// Create runtime with real API keys - NO HARD-CODED FALLBACKS
+const runtime = {
+  getSetting: (key: string) => {
+    if (key === 'FILE_LOGGING') return 'true';
+    const value = process.env[key];
+    if (!value) {
+      console.warn(`⚠️  Environment variable ${key} not found`);
+    }
+    return value || null;
+  },
+  useModel: async (type: any, params: any) => {
+    // This example file should be updated to use real API calls
+    throw new Error('This example file needs to be updated to use real LLM APIs. Use the real-runtime.ts implementation instead.');
+  },
+  logger: {
+    info: console.log,
+    warn: console.warn,
+    error: console.error,
+    debug: () => {}, // Suppress debug logs for cleaner output
+  },
+  getService: () => null,
+} as unknown as IAgentRuntime;
+
+async function runRealResearch() {
+  console.log('🔬 ElizaOS Research Plugin - Real Research Demo\n');
+  console.log('📁 File logging enabled - outputs will be saved to research_logs/\n');
+
+  // Create research service
+  const service = new ResearchService(runtime);
+
+  // Research queries to test
+  const queries = [
+    'What are the latest breakthroughs in AI and machine learning in 2024?',
+    'Compare the environmental policies of Nordic countries',
+    'Analyze the impact of remote work on productivity post-pandemic'
+  ];
+
+  console.log(`Running ${queries.length} research projects...\n`);
+
+  for (let i = 0; i < queries.length; i++) {
+    const query = queries[i];
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`Research ${i + 1}/${queries.length}: ${query}`);
+    console.log('='.repeat(80) + '\n');
+
+    try {
+      // Start research
+      console.log('🚀 Starting research...');
+      const project = await service.createResearchProject(query);
+      console.log(`📋 Project ID: ${project.id}`);
+      console.log(`🏷️  Domain: ${project.metadata.domain}`);
+      console.log(`📊 Task Type: ${project.metadata.taskType}`);
+
+      // Wait for research to complete
+      console.log('\n⏳ Research in progress...');
+      
+      // Check status periodically
+      let completed = false;
+      let attempts = 0;
+      const maxAttempts = 30; // 30 seconds max
+      
+      while (!completed && attempts < maxAttempts) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        const currentProject = await service.getProject(project.id);
+        
+        if (currentProject) {
+          process.stdout.write(`\r📍 Status: ${currentProject.status} | Phase: ${currentProject.phase || 'N/A'}`);
+          
+          if (currentProject.status === 'completed' || currentProject.status === 'failed') {
+            completed = true;
+            console.log('\n');
+          }
+        }
+        attempts++;
+      }
+
+      // Get final project state
+      const finalProject = await service.getProject(project.id);
+      
+      if (finalProject) {
+        console.log(`\n✅ Research Status: ${finalProject.status}`);
+        console.log(`📑 Sources Found: ${finalProject.sources.length}`);
+        console.log(`💡 Key Findings: ${finalProject.findings.length}`);
+        
+        if (finalProject.report) {
+          console.log(`📝 Report Generated: ${finalProject.report.wordCount} words`);
+          console.log(`⏱️  Reading Time: ${finalProject.report.readingTime} minutes`);
+        }
+        
+        // The report should already be saved by the service
+        console.log('\n📁 Files saved to research_logs/ directory');
+      }
+
+    } catch (error) {
+      console.error(`\n❌ Error with research: ${error}`);
+    }
+
+    // Small delay between research projects
+    if (i < queries.length - 1) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  }
+
+  // Show saved files
+  console.log('\n' + '='.repeat(80));
+  console.log('📂 Research Outputs Saved:\n');
+  
+  try {
+    const logsDir = path.join(process.cwd(), 'research_logs');
+    const files = await fs.readdir(logsDir);
+    const mdFiles = files.filter(f => f.endsWith('.md')).sort();
+    
+    if (mdFiles.length > 0) {
+      console.log('Markdown Reports:');
+      mdFiles.forEach(file => {
+        console.log(`  📄 ${file}`);
+      });
+      
+      console.log('\n💡 To view a report, run:');
+      console.log(`   cat research_logs/${mdFiles[0]}`);
+      
+      console.log('\n💡 To view all reports:');
+      console.log('   ls -la research_logs/');
+    } else {
+      console.log('No reports found in research_logs/');
+    }
+  } catch (error) {
+    console.log('research_logs/ directory not found yet');
+  }
+}
+
+// Run the research
+runRealResearch().catch(console.error); 

package/src/examples/save-research-output.ts

@@ -0,0 +1,133 @@
+#!/usr/bin/env bun
+/**
+ * Example script showing how to save research outputs to files
+ * Run with: bun run src/examples/save-research-output.ts
+ */
+
+import { ResearchService } from '../service';
+import { IAgentRuntime } from '@elizaos/core';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Create a mock runtime for demonstration
+const mockRuntime = {
+  getSetting: (key: string) => {
+    const settings: Record<string, string> = {
+      TAVILY_API_KEY: process.env.TAVILY_API_KEY || '',
+      EXA_API_KEY: process.env.EXA_API_KEY || '',
+      SERPAPI_API_KEY: process.env.SERPAPI_API_KEY || '',
+      FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY || '',
+    };
+    return settings[key];
+  },
+  useModel: async () => 'mock response',
+  logger: {
+    info: console.log,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug,
+  },
+  getService: () => null,
+} as unknown as IAgentRuntime;
+
+async function saveResearchOutputs() {
+  console.log('🔬 ElizaOS Research Plugin - Output Example\n');
+  
+  // Create research service
+  const service = new ResearchService(mockRuntime);
+  
+  // Start a research project
+  console.log('1️⃣ Starting research project...');
+  const project = await service.createResearchProject(
+    'What are the latest breakthroughs in quantum computing in 2024?'
+  );
+  
+  console.log(`   Project ID: ${project.id}`);
+  console.log(`   Status: ${project.status}`);
+  
+  // Wait for research to complete (in real usage, this would take longer)
+  console.log('\n2️⃣ Waiting for research to complete...');
+  await new Promise(resolve => setTimeout(resolve, 5000));
+  
+  // Get the updated project
+  const completedProject = await service.getProject(project.id);
+  
+  if (!completedProject) {
+    console.error('❌ Project not found');
+    return;
+  }
+  
+  // Create output directory
+  const outputDir = path.join(process.cwd(), 'research-outputs', project.id);
+  await fs.mkdir(outputDir, { recursive: true });
+  console.log(`\n3️⃣ Created output directory: ${outputDir}`);
+  
+  // Save different formats
+  console.log('\n4️⃣ Saving research outputs...\n');
+  
+  try {
+    // 1. Save as JSON (complete project data)
+    const jsonPath = path.join(outputDir, 'research-complete.json');
+    const jsonData = await service.exportProject(project.id, 'json');
+    await fs.writeFile(jsonPath, jsonData, 'utf-8');
+    console.log(`   ✅ JSON saved to: ${jsonPath}`);
+    
+    // 2. Save as Markdown (human-readable report)
+    const mdPath = path.join(outputDir, 'research-report.md');
+    const mdData = await service.exportProject(project.id, 'markdown');
+    await fs.writeFile(mdPath, mdData, 'utf-8');
+    console.log(`   ✅ Markdown saved to: ${mdPath}`);
+    
+    // 3. Save as DeepResearch Bench format
+    const benchPath = path.join(outputDir, 'deepresearch-bench.json');
+    const benchData = await service.exportProject(project.id, 'deepresearch');
+    await fs.writeFile(benchPath, benchData, 'utf-8');
+    console.log(`   ✅ DeepResearch format saved to: ${benchPath}`);
+    
+    // 4. Save metadata separately
+    const metaPath = path.join(outputDir, 'metadata.json');
+    const metadata = {
+      projectId: project.id,
+      query: project.query,
+      status: completedProject.status,
+      createdAt: new Date(project.createdAt).toISOString(),
+      completedAt: completedProject.completedAt ? new Date(completedProject.completedAt).toISOString() : null,
+      domain: completedProject.metadata.domain,
+      taskType: completedProject.metadata.taskType,
+      sourceCount: completedProject.sources.length,
+      findingCount: completedProject.findings.length,
+      evaluationScore: completedProject.evaluationResults?.overallScore || 'Not evaluated',
+    };
+    await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2), 'utf-8');
+    console.log(`   ✅ Metadata saved to: ${metaPath}`);
+    
+    // 5. Create a summary file
+    const summaryPath = path.join(outputDir, 'summary.txt');
+    const summary = `Research Summary
+================
+Query: ${project.query}
+Status: ${completedProject.status}
+Domain: ${completedProject.metadata.domain}
+Sources Found: ${completedProject.sources.length}
+Key Findings: ${completedProject.findings.length}
+
+Top Findings:
+${completedProject.findings
+  .sort((a, b) => b.relevance - a.relevance)
+  .slice(0, 5)
+  .map((f, i) => `${i + 1}. ${f.content.substring(0, 150)}...`)
+  .join('\n')}
+`;
+    await fs.writeFile(summaryPath, summary, 'utf-8');
+    console.log(`   ✅ Summary saved to: ${summaryPath}`);
+    
+  } catch (error) {
+    console.error('❌ Error saving outputs:', error);
+  }
+  
+  console.log('\n5️⃣ All outputs saved successfully!');
+  console.log(`\n📁 View your research outputs in: ${outputDir}`);
+}
+
+// Run the example
+saveResearchOutputs().catch(console.error);