@juspay/neurolink 1.5.3 → 1.6.0

package/dist/mcp/servers/ai-providers/ai-workflow-tools.js

@@ -62,64 +62,80 @@ export const generateTestCasesTool = {
     inputSchema: generateTestCasesSchema,
     isImplemented: true,
     permissions: ['write'],
-    version: '1.0.0',
+    version: '2.0.0', // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
             const validatedParams = generateTestCasesSchema.parse(params);
             const { codeFunction, testTypes, framework, coverageTarget, includeAsyncTests } = validatedParams;
-            // Simulate test case generation with realistic data
-            const testCases = [];
-            // Generate test cases based on requested types
-            if (testTypes.includes('unit')) {
-                testCases.push({
-                    name: 'should handle basic input correctly',
-                    type: 'unit',
-                    code: `test('should handle basic input correctly', () => {\n  const result = ${extractFunctionName(codeFunction)}('test');\n  expect(result).toBeDefined();\n  expect(typeof result).toBe('string');\n});`,
-                    description: 'Tests basic functionality with standard input',
-                    assertions: 2
-                });
+            // Get AI provider for real test case generation
+            const providerName = await getBestProvider();
+            const provider = await AIProviderFactory.createProvider(providerName);
+            if (!provider) {
+                throw new Error(`Failed to create AI provider: ${providerName}`);
             }
-            if (testTypes.includes('edge-cases')) {
-                testCases.push({
-                    name: 'should handle null/undefined gracefully',
-                    type: 'edge-case',
-                    code: `test('should handle null/undefined gracefully', () => {\n  expect(() => ${extractFunctionName(codeFunction)}(null)).not.toThrow();\n  expect(() => ${extractFunctionName(codeFunction)}(undefined)).not.toThrow();\n});`,
-                    description: 'Tests edge cases with null and undefined inputs',
-                    assertions: 2
-                });
-            }
-            if (testTypes.includes('integration') && includeAsyncTests) {
-                testCases.push({
-                    name: 'should integrate with async operations',
-                    type: 'integration',
-                    code: `test('should integrate with async operations', async () => {\n  const result = await ${extractFunctionName(codeFunction)}Async('test');\n  expect(result).toBeDefined();\n  expect(result.status).toBe('success');\n});`,
-                    description: 'Tests integration with asynchronous operations',
-                    assertions: 2
-                });
+            // Create structured prompt for test case generation
+            const prompt = `Generate ${testTypes.join(', ')} test cases for this ${framework} function:
+
+${codeFunction}
+
+Requirements:
+- Test types: ${testTypes.join(', ')}
+- Framework: ${framework}
+- Coverage target: ${coverageTarget}%
+- Include async tests: ${includeAsyncTests}
+- Generate realistic, executable test code
+
+Return ONLY a valid JSON object with this exact structure:
+{
+  "testCases": [
+    {
+      "name": "descriptive test name",
+      "type": "unit|integration|edge-cases|performance|security",
+      "code": "complete executable test code for ${framework}",
+      "description": "what this test validates",
+      "assertions": number_of_assertions
+    }
+  ]
+}
+
+Generate 3-5 comprehensive test cases covering the requested types.`;
+            const result = await provider.generateText({
+                prompt,
+                maxTokens: 1200,
+                temperature: 0.3 // Lower temperature for more consistent structured output
+            });
+            if (!result || !result.text) {
+                throw new Error('AI provider returned no result for test case generation.');
             }
-            const result = {
+            // Parse AI response
+            const aiResponse = JSON.parse(result.text);
+            const testCases = aiResponse.testCases || [];
+            const executionTime = Date.now() - startTime;
+            const responseData = {
                 testCases,
                 framework,
-                coverageEstimate: Math.min(coverageTarget, 85 + Math.random() * 10),
+                coverageEstimate: Math.min(coverageTarget, 80 + Math.random() * 15),
                 totalTests: testCases.length,
-                totalAssertions: testCases.reduce((sum, tc) => sum + tc.assertions, 0),
-                executionTime: Date.now() - startTime
+                totalAssertions: testCases.reduce((sum, tc) => sum + (tc.assertions || 1), 0),
+                generatedAt: new Date().toISOString(),
+                aiProvider: providerName
             };
             return {
                 success: true,
-                data: result,
+                data: responseData,
                 usage: {
-                    executionTime: Date.now() - startTime,
-                    provider: 'workflow-engine',
-                    model: 'test-generator'
+                    ...result.usage,
+                    executionTime,
+                    provider: providerName,
+                    model: 'test-case-generator'
                 },
                 metadata: {
                     toolName: 'generate-test-cases',
                     serverId: 'neurolink-ai-core',
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime: Date.now() - startTime
+                    executionTime
                 }
             };
         }
@@ -150,43 +166,89 @@ export const refactorCodeTool = {
     inputSchema: refactorCodeSchema,
     isImplemented: true,
     permissions: ['write'],
-    version: '1.0.0',
+    version: '2.0.0', // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
             const validatedParams = refactorCodeSchema.parse(params);
             const { code, language, objectives, preserveFunctionality, styleGuide } = validatedParams;
-            // Simulate code refactoring with improvements
-            const refactoredCode = simulateRefactoring(code, objectives, styleGuide);
-            const result = {
-                refactoredCode,
-                changes: [
-                    'Extracted magic numbers into named constants',
-                    'Simplified conditional logic using early returns',
-                    'Renamed variables for clarity',
-                    'Added proper error handling'
-                ],
-                improvements: objectives.map(obj => `Improved ${obj}`),
+            // Get AI provider for real code refactoring
+            const providerName = await getBestProvider();
+            const provider = await AIProviderFactory.createProvider(providerName);
+            if (!provider) {
+                throw new Error(`Failed to create AI provider: ${providerName}`);
+            }
+            // Create structured prompt for code refactoring
+            const prompt = `Refactor this ${language} code focusing on: ${objectives.join(', ')}
+
+Original code:
+\`\`\`${language}
+${code}
+\`\`\`
+
+Requirements:
+- Language: ${language}
+- Objectives: ${objectives.join(', ')}
+- Style guide: ${styleGuide || 'standard best practices'}
+- Preserve functionality: ${preserveFunctionality}
+- Provide clean, production-ready code
+
+Return ONLY a valid JSON object with this exact structure:
+{
+  "refactoredCode": "improved code here with proper formatting",
+  "changes": ["specific change 1", "specific change 2", "specific change 3"],
+  "improvements": ["improvement achieved 1", "improvement achieved 2"],
+  "metrics": {
+    "linesReduced": positive_number_or_0,
+    "complexityReduction": percentage_number,
+    "readabilityScore": score_out_of_100
+  }
+}
+
+Focus on real, actionable improvements based on the specified objectives.`;
+            const result = await provider.generateText({
+                prompt,
+                maxTokens: 1000,
+                temperature: 0.2 // Very low temperature for consistent refactoring
+            });
+            if (!result || !result.text) {
+                throw new Error('AI provider returned no result for code refactoring.');
+            }
+            // Parse AI response
+            const aiResponse = JSON.parse(result.text);
+            const executionTime = Date.now() - startTime;
+            const responseData = {
+                refactoredCode: aiResponse.refactoredCode || code,
+                changes: aiResponse.changes || ['Code refactored successfully'],
+                improvements: aiResponse.improvements || objectives.map(obj => `Improved ${obj}`),
                 metrics: {
-                    linesReduced: Math.floor(Math.random() * 10) + 5,
-                    complexityReduction: Math.floor(Math.random() * 20) + 10,
-                    readabilityScore: 85 + Math.floor(Math.random() * 10)
+                    linesReduced: aiResponse.metrics?.linesReduced || 0,
+                    complexityReduction: aiResponse.metrics?.complexityReduction || 15,
+                    readabilityScore: aiResponse.metrics?.readabilityScore || 85
                 }
             };
             return {
                 success: true,
-                data: result,
+                data: {
+                    ...responseData,
+                    originalCode: code,
+                    language,
+                    objectives,
+                    generatedAt: new Date().toISOString(),
+                    aiProvider: providerName
+                },
                 usage: {
-                    executionTime: Date.now() - startTime,
-                    provider: 'workflow-engine',
-                    model: 'refactor-engine'
+                    ...result.usage,
+                    executionTime,
+                    provider: providerName,
+                    model: 'code-refactorer'
                 },
                 metadata: {
                     toolName: 'refactor-code',
                     serverId: 'neurolink-ai-core',
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime: Date.now() - startTime
+                    executionTime
                 }
             };
         }
@@ -217,68 +279,82 @@ export const generateDocumentationTool = {
     inputSchema: generateDocumentationSchema,
     isImplemented: true,
     permissions: ['read'],
-    version: '1.0.0',
+    version: '2.0.0', // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
             const validatedParams = generateDocumentationSchema.parse(params);
             const { code, language, documentationType, includeExamples, detailLevel } = validatedParams;
-            // Generate documentation based on type
-            let documentation = '';
-            const sections = [];
-            const examples = [];
-            if (documentationType === 'jsdoc') {
-                documentation = `/**
- * ${extractFunctionName(code)} - Processes input data and returns formatted result
- *
- * @param {string} input - The input data to process
- * @param {Object} options - Configuration options
- * @param {boolean} options.validate - Whether to validate input
- * @param {number} options.timeout - Operation timeout in milliseconds
- * @returns {Promise<Object>} Processed result object
- * @throws {Error} If input validation fails
- */`;
-                sections.push('Parameters', 'Returns', 'Throws');
+            // Get AI provider for real documentation generation
+            const providerName = await getBestProvider();
+            const provider = await AIProviderFactory.createProvider(providerName);
+            if (!provider) {
+                throw new Error(`Failed to create AI provider: ${providerName}`);
             }
-            else if (documentationType === 'markdown') {
-                documentation = `# ${extractFunctionName(code)}
+            // Create structured prompt for documentation generation
+            const prompt = `Generate ${documentationType} documentation for this ${language} code:
 
-## Description
-Processes input data and returns formatted result with validation and timeout support.
+\`\`\`${language}
+${code}
+\`\`\`
 
-## Parameters
-- \`input\` (string): The input data to process
-- \`options\` (object): Configuration options
-  - \`validate\` (boolean): Whether to validate input
-  - \`timeout\` (number): Operation timeout in milliseconds
+Requirements:
+- Language: ${language}
+- Documentation type: ${documentationType}
+- Detail level: ${detailLevel}
+- Include examples: ${includeExamples}
+- Generate professional, comprehensive documentation
 
-## Returns
-Promise<Object>: Processed result object`;
-                sections.push('Description', 'Parameters', 'Returns');
-            }
-            if (includeExamples) {
-                examples.push(`// Basic usage\nconst result = await ${extractFunctionName(code)}('data', { validate: true });`, `// With timeout\nconst result = await ${extractFunctionName(code)}('data', { timeout: 5000 });`);
+Return ONLY a valid JSON object with this exact structure:
+{
+  "documentation": "formatted documentation string in ${documentationType} format",
+  "sections": ["list of documentation sections included"],
+  "examples": ${includeExamples ? '["code examples with usage"]' : '[]'},
+  "coverage": percentage_number_representing_documentation_completeness
+}
+
+Focus on creating accurate, useful documentation that explains the code's purpose, parameters, return values, and usage patterns.`;
+            const result = await provider.generateText({
+                prompt,
+                maxTokens: 1200,
+                temperature: 0.3 // Moderate temperature for creative but structured documentation
+            });
+            if (!result || !result.text) {
+                throw new Error('AI provider returned no result for documentation generation.');
             }
-            const result = {
-                documentation,
-                sections,
-                examples,
-                coverage: detailLevel === 'comprehensive' ? 95 : detailLevel === 'standard' ? 80 : 60
+            // Parse AI response
+            const aiResponse = JSON.parse(result.text);
+            const executionTime = Date.now() - startTime;
+            const responseData = {
+                documentation: aiResponse.documentation || 'Documentation generated successfully',
+                sections: aiResponse.sections || ['Overview'],
+                examples: aiResponse.examples || [],
+                coverage: aiResponse.coverage || (detailLevel === 'comprehensive' ? 95 : detailLevel === 'standard' ? 80 : 60)
             };
             return {
                 success: true,
-                data: result,
+                data: {
+                    ...responseData,
+                    originalCode: code,
+                    language,
+                    documentationType,
+                    detailLevel,
+                    includeExamples,
+                    generatedAt: new Date().toISOString(),
+                    aiProvider: providerName
+                },
                 usage: {
-                    executionTime: Date.now() - startTime,
-                    provider: 'workflow-engine',
-                    model: 'doc-generator'
+                    ...result.usage,
+                    executionTime,
+                    provider: providerName,
+                    model: 'documentation-generator'
                 },
                 metadata: {
                     toolName: 'generate-documentation',
                     serverId: 'neurolink-ai-core',
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime: Date.now() - startTime
+                    executionTime
                 }
             };
         }
@@ -309,75 +385,95 @@ export const debugAIOutputTool = {
     inputSchema: debugAIOutputSchema,
     isImplemented: true,
     permissions: ['read', 'analytics'],
-    version: '1.0.0',
+    version: '2.0.0', // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
             const validatedParams = debugAIOutputSchema.parse(params);
             const { aiOutput, expectedBehavior, context: debugContext, outputType, includeFixSuggestions } = validatedParams;
-            // Analyze AI output for issues
-            const issues = [];
-            const suggestions = [];
-            const possibleCauses = [];
-            // Simulate issue detection based on output type
-            if (outputType === 'code') {
-                if (!aiOutput.includes('error handling')) {
-                    issues.push({
-                        type: 'missing-error-handling',
-                        severity: 'medium',
-                        description: 'Code lacks proper error handling',
-                        location: 'throughout'
-                    });
-                    suggestions.push('Add try-catch blocks for error handling');
-                }
-                if (aiOutput.length < 50) {
-                    issues.push({
-                        type: 'incomplete-implementation',
-                        severity: 'high',
-                        description: 'Code appears incomplete or truncated',
-                        location: 'end of output'
-                    });
-                    possibleCauses.push('Token limit reached', 'Prompt ambiguity');
-                }
+            // Get AI provider for real output analysis
+            const providerName = await getBestProvider();
+            const provider = await AIProviderFactory.createProvider(providerName);
+            if (!provider) {
+                throw new Error(`Failed to create AI provider: ${providerName}`);
             }
-            else if (outputType === 'text') {
-                if (aiOutput.toLowerCase() !== aiOutput && aiOutput.toUpperCase() !== aiOutput) {
-                    // Mixed case - check for consistency
-                    if (Math.random() > 0.7) {
-                        issues.push({
-                            type: 'inconsistent-formatting',
-                            severity: 'low',
-                            description: 'Inconsistent text formatting detected',
-                            location: 'various'
-                        });
-                    }
-                }
-            }
-            // Add general suggestions if requested
-            if (includeFixSuggestions) {
-                suggestions.push('Refine the prompt for clearer instructions', 'Adjust temperature parameter for more consistent output', 'Consider using system prompts for better context');
+            // Create structured prompt for AI output debugging
+            const prompt = `Analyze this AI-generated ${outputType} output for issues and improvements:
+
+AI Output to Debug:
+\`\`\`
+${aiOutput}
+\`\`\`
+
+Expected Behavior:
+${expectedBehavior}
+
+Context: ${debugContext || 'None provided'}
+Output Type: ${outputType}
+Include Fix Suggestions: ${includeFixSuggestions}
+
+Analyze the output for:
+1. Quality issues (completeness, accuracy, formatting)
+2. Technical problems (syntax errors, logical flaws)
+3. Content issues (relevance, clarity, consistency)
+4. Improvement opportunities
+
+Return ONLY a valid JSON object with this exact structure:
+{
+  "issues": [
+    {
+      "type": "issue-category",
+      "severity": "low|medium|high",
+      "description": "detailed description of the issue",
+      "location": "where in output this occurs"
+    }
+  ],
+  "suggestions": ["actionable improvement suggestion 1", "suggestion 2"],
+  "possibleCauses": ["potential cause 1", "potential cause 2"],
+  "fixedOutput": ${includeFixSuggestions ? '"corrected version if possible"' : 'null'}
+}
+
+Provide thorough, actionable analysis focused on improving AI output quality.`;
+            const result = await provider.generateText({
+                prompt,
+                maxTokens: 1000,
+                temperature: 0.4 // Moderate temperature for analytical thinking
+            });
+            if (!result || !result.text) {
+                throw new Error('AI provider returned no result for output debugging.');
             }
-            const result = {
-                issues,
-                suggestions,
-                possibleCauses: possibleCauses.length > 0 ? possibleCauses : ['Prompt clarity', 'Model limitations'],
-                fixedOutput: issues.length > 0 && includeFixSuggestions ?
-                    `${aiOutput}\n// TODO: Add error handling and validation` : undefined
+            // Parse AI response
+            const aiResponse = JSON.parse(result.text);
+            const executionTime = Date.now() - startTime;
+            const responseData = {
+                issues: aiResponse.issues || [],
+                suggestions: aiResponse.suggestions || ['Consider refining the prompt for clearer instructions'],
+                possibleCauses: aiResponse.possibleCauses || ['Prompt clarity', 'Model limitations'],
+                fixedOutput: aiResponse.fixedOutput || undefined
             };
             return {
                 success: true,
-                data: result,
+                data: {
+                    ...responseData,
+                    originalOutput: aiOutput,
+                    expectedBehavior,
+                    outputType,
+                    analysisContext: debugContext,
+                    generatedAt: new Date().toISOString(),
+                    aiProvider: providerName
+                },
                 usage: {
-                    executionTime: Date.now() - startTime,
-                    provider: 'workflow-engine',
-                    model: 'debug-analyzer'
+                    ...result.usage,
+                    executionTime,
+                    provider: providerName,
+                    model: 'ai-output-debugger'
                 },
                 metadata: {
                     toolName: 'debug-ai-output',
                     serverId: 'neurolink-ai-core',
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime: Date.now() - startTime
+                    executionTime
                 }
             };
         }

package/dist/neurolink.d.ts

@@ -7,7 +7,7 @@
 import type { AIProviderName } from './core/types.js';
 export interface TextGenerationOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'auto';
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'huggingface' | 'ollama' | 'mistral' | 'auto';
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
@@ -15,7 +15,7 @@ export interface TextGenerationOptions {
 }
 export interface StreamTextOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'auto';
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'huggingface' | 'ollama' | 'mistral' | 'auto';
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;

package/dist/neurolink.js

@@ -15,15 +15,20 @@ export class NeuroLink {
         const startTime = Date.now();
         const functionTag = 'NeuroLink.generateText';
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
+        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama'];
         const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
-        // If specific provider requested, try that first, then fallback to priority order
+        // Local providers that should not fall back when explicitly requested
+        const localProviders = ['ollama'];
+        // If specific provider requested, check if we should allow fallback
         const tryProviders = requestedProvider
-            ? [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)]
+            ? (localProviders.includes(requestedProvider)
+                ? [requestedProvider] // No fallback for local providers
+                : [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)])
             : providerPriority;
-        logger.debug(`[${functionTag}] Starting text generation with fallback`, {
+        logger.debug(`[${functionTag}] Starting text generation`, {
             requestedProvider: requestedProvider || 'auto',
             tryProviders,
+            allowFallback: !requestedProvider || !localProviders.includes(requestedProvider),
             promptLength: options.prompt.length
         });
         let lastError = null;
@@ -78,15 +83,20 @@ export class NeuroLink {
     async generateTextStream(options) {
         const functionTag = 'NeuroLink.generateTextStream';
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
+        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama'];
         const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
-        // If specific provider requested, try that first, then fallback to priority order
+        // Local providers that should not fall back when explicitly requested
+        const localProviders = ['ollama'];
+        // If specific provider requested, check if we should allow fallback
         const tryProviders = requestedProvider
-            ? [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)]
+            ? (localProviders.includes(requestedProvider)
+                ? [requestedProvider] // No fallback for local providers
+                : [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)])
             : providerPriority;
-        logger.debug(`[${functionTag}] Starting stream generation with fallback`, {
+        logger.debug(`[${functionTag}] Starting stream generation`, {
             requestedProvider: requestedProvider || 'auto',
             tryProviders,
+            allowFallback: !requestedProvider || !localProviders.includes(requestedProvider),
             promptLength: options.prompt.length
         });
         let lastError = null;

package/dist/providers/huggingFace.d.ts

@@ -0,0 +1,31 @@
+import type { ZodType, ZodTypeDef } from 'zod';
+import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from 'ai';
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+export declare class HuggingFace implements AIProvider {
+    private modelName;
+    private client;
+    /**
+     * Initializes a new instance of HuggingFace
+     * @param modelName - Optional model name to override the default from config
+     */
+    constructor(modelName?: string | null);
+    /**
+     * Gets the appropriate model instance
+     * @private
+     */
+    private getModel;
+    /**
+     * Processes text using streaming approach with enhanced error handling callbacks
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to StreamTextResult or null if operation fails
+     */
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * Processes text using non-streaming approach with optional schema validation
+     * @param prompt - The input text prompt to analyze
+     * @param analysisSchema - Optional Zod schema or Schema object for output validation
+     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     */
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}