Helios-9 MCP Server

Instructions

Implementation Reference

• src/tools/documents.ts:721-768 (handler)

  Main handler function that executes the analyze_document_content tool. Fetches document, runs specified analyses (readability, completeness, etc.), generates suggestions, and returns overall score.
  export const analyzeDocumentContent = requireAuth(async (args: any) => { const { document_id, analysis_types, include_suggestions } = AnalyzeDocumentContentSchema.parse(args) logger.info('Analyzing document content', { document_id, analysis_types }) const document = await supabaseService.getDocument(document_id) if (!document) { throw new Error('Document not found') } const analysis: any = { document_id, title: document.title, analyzed_at: new Date().toISOString(), results: {} } // Perform requested analyses for (const analysisType of analysis_types) { switch (analysisType) { case 'readability': analysis.results.readability = analyzeReadability(document.content) break case 'completeness': analysis.results.completeness = analyzeCompleteness(document) break case 'ai_optimization': analysis.results.ai_optimization = analyzeAIOptimization(document) break case 'link_analysis': analysis.results.link_analysis = analyzeLinkStructure(document.content) break case 'structure_analysis': analysis.results.structure_analysis = analyzeDocumentStructure(document.content) break } } // Generate improvement suggestions if (include_suggestions) { analysis.suggestions = generateImprovementSuggestions(analysis.results, document) } // Calculate overall score analysis.overall_score = calculateOverallDocumentScore(analysis.results) return analysis })
• src/tools/documents.ts:715-719 (schema)

  Zod input schema for validating parameters: document_id (required), analysis_types (array of analysis enums), include_suggestions (boolean).
  const AnalyzeDocumentContentSchema = z.object({ document_id: z.string().min(1), analysis_types: z.array(z.enum(['readability', 'completeness', 'ai_optimization', 'link_analysis', 'structure_analysis'])).default(['readability', 'completeness']), include_suggestions: z.boolean().default(true) })
• src/tools/documents.ts:686-713 (registration)

  MCPTool registration object defining the tool name 'analyze_document_content', description, and input schema structure.
  export const analyzeDocumentContentTool: MCPTool = { name: 'analyze_document_content', description: 'Perform advanced analysis on document content', inputSchema: { type: 'object', properties: { document_id: { type: 'string', description: 'ID of the document to analyze' }, analysis_types: { type: 'array', items: { type: 'string', enum: ['readability', 'completeness', 'ai_optimization', 'link_analysis', 'structure_analysis'] }, default: ['readability', 'completeness'], description: 'Types of analysis to perform' }, include_suggestions: { type: 'boolean', default: true, description: 'Whether to include improvement suggestions' } }, required: ['document_id'] } }
• src/tools/documents.ts:1346-1357 (registration)

  Export of all document handlers, including analyze_document_content mapped to its handler function.
  export const documentHandlers = { list_documents: listDocuments, create_document: createDocument, get_document: getDocument, update_document: updateDocument, search_documents: searchDocuments, get_document_context: getDocumentContext, add_document_collaborator: addDocumentCollaborator, analyze_document_content: analyzeDocumentContent, get_document_collaboration: getDocumentCollaboration, generate_document_template: generateDocumentTemplate, bulk_document_operations: bulkDocumentOperations
• src/tools/documents.ts:768-1024 (helper)

  Supporting helper functions (analyzeReadability, analyzeCompleteness, etc.) that implement specific analysis types used by the main handler.
  }) /** * Get document collaboration history */ export const getDocumentCollaborationTool: MCPTool = { name: 'get_document_collaboration', description: 'Get collaboration history and current collaborators for a document', inputSchema: { type: 'object', properties: { document_id: { type: 'string', description: 'ID of the document' }, include_activity: { type: 'boolean', default: true, description: 'Whether to include recent activity' }, time_range: { type: 'string', enum: ['day', 'week', 'month', 'all'], default: 'week', description: 'Time range for activity' } }, required: ['document_id'] } } const GetDocumentCollaborationSchema = z.object({ document_id: z.string().min(1), include_activity: z.boolean().default(true), time_range: z.enum(['day', 'week', 'month', 'all']).default('week') }) export const getDocumentCollaboration = requireAuth(async (args: any) => { const { document_id, include_activity, time_range } = GetDocumentCollaborationSchema.parse(args) logger.info('Getting document collaboration', { document_id, time_range }) const document = await supabaseService.getDocument(document_id) if (!document) { throw new Error('Document not found') } // Get collaborators const collaborations = await supabaseService.getDocumentCollaborations(document_id) // Get activity if requested let activity = [] if (include_activity) { activity = await getDocumentActivity(document_id, time_range) } // Analyze collaboration patterns const collaborationStats = analyzeCollaborationPatterns(collaborations, activity) return { document: { id: document.id, title: document.title, created_by: document.created_by }, collaborators: collaborations.map(c => ({ user_id: c.user_id, permission_level: c.permission_level, status: c.status, joined_at: c.invited_at, last_activity: activity.filter(a => a.user_id === c.user_id)[0]?.timestamp })), activity: activity.slice(0, 50), // Limit to 50 recent activities statistics: collaborationStats } }) /** * Generate document templates */ export const generateDocumentTemplateTool: MCPTool = { name: 'generate_document_template', description: 'Generate a document template based on type and requirements', inputSchema: { type: 'object', properties: { template_type: { type: 'string', enum: ['readme', 'api_doc', 'meeting_notes', 'technical_spec', 'user_guide', 'project_proposal'], description: 'Type of template to generate' }, project_context: { type: 'object', properties: { name: { type: 'string' }, description: { type: 'string' }, tech_stack: { type: 'array', items: { type: 'string' } }, team_size: { type: 'number' } }, description: 'Project context for template customization' }, ai_optimized: { type: 'boolean', default: true, description: 'Whether to include AI-optimization features' }, include_examples: { type: 'boolean', default: true, description: 'Whether to include example content' } }, required: ['template_type'] } } const GenerateDocumentTemplateSchema = z.object({ template_type: z.enum(['readme', 'api_doc', 'meeting_notes', 'technical_spec', 'user_guide', 'project_proposal']), project_context: z.object({ name: z.string().optional(), description: z.string().optional(), tech_stack: z.array(z.string()).optional(), team_size: z.number().optional() }).optional(), ai_optimized: z.boolean().default(true), include_examples: z.boolean().default(true) }) export const generateDocumentTemplate = requireAuth(async (args: any) => { const { template_type, project_context, ai_optimized, include_examples } = GenerateDocumentTemplateSchema.parse(args) logger.info('Generating document template', { template_type, ai_optimized }) const template = generateTemplateContent(template_type, project_context, ai_optimized, include_examples) return { template_type, content: template.content, frontmatter: template.frontmatter, sections: template.sections, ai_instructions: ai_optimized ? template.ai_instructions : undefined, usage_tips: template.usage_tips } }) /** * Bulk document operations */ export const bulkDocumentOperationsTool: MCPTool = { name: 'bulk_document_operations', description: 'Perform bulk operations on multiple documents', inputSchema: { type: 'object', properties: { document_ids: { type: 'array', items: { type: 'string' }, description: 'Array of document IDs' }, operation: { type: 'string', enum: ['update_metadata', 'add_tags', 'change_visibility', 'archive', 'analyze'], description: 'Operation to perform' }, operation_data: { type: 'object', description: 'Data for the operation' } }, required: ['document_ids', 'operation'] } } const BulkDocumentOperationsSchema = z.object({ document_ids: z.array(z.string().min(1)).min(1), operation: z.enum(['update_metadata', 'add_tags', 'change_visibility', 'archive', 'analyze']), operation_data: z.record(z.any()).optional() }) export const bulkDocumentOperations = requireAuth(async (args: any) => { const { document_ids, operation, operation_data } = BulkDocumentOperationsSchema.parse(args) logger.info('Performing bulk document operations', { document_count: document_ids.length, operation }) const results = [] const now = new Date().toISOString() for (const document_id of document_ids) { try { let result switch (operation) { case 'update_metadata': // metadata field doesn't exist in the database schema result = await supabaseService.updateDocument(document_id, { updated_at: now }) break case 'add_tags': const doc = await supabaseService.getDocument(document_id) const existingTags = [] // metadata doesn't exist in the database schema const newTags = operation_data?.tags || [] // metadata field doesn't exist in the database schema result = await supabaseService.updateDocument(document_id, { updated_at: now }) break case 'change_visibility': // visibility field doesn't exist in the database schema result = await supabaseService.updateDocument(document_id, { updated_at: now }) break case 'archive': // status and metadata fields don't exist in the database schema result = await supabaseService.updateDocument(document_id, { updated_at: now }) break case 'analyze': result = await analyzeDocumentContent({ document_id, analysis_types: operation_data?.analysis_types || ['readability', 'completeness'], include_suggestions: true }) break default: throw new Error(`Unknown operation: ${operation}`) } results.push({ document_id, success: true, result }) } catch (error) { logger.error(`Failed operation ${operation} on document ${document_id}:`, error) results.push({ document_id, success: false, error: error instanceof Error ? error.message : 'Unknown error' }) } } return { operation, summary: { total_documents: document_ids.length, successful_operations: results.filter(r => r.success).length, failed_operations: results.filter(r => !r.success).length }, results } }) // Helper functions for document analysis function analyzeReadability(content: string): any {