@juspay/neurolink 7.6.1 → 7.7.1

package/CHANGELOG.md

@@ -1,16 +1,27 @@
-## [7.6.1](https://github.com/juspay/neurolink/compare/v7.6.0...v7.6.1) (2025-08-09)
+## [7.7.1](https://github.com/juspay/neurolink/compare/v7.7.0...v7.7.1) (2025-08-11)
 
 
 ### Bug Fixes
 
-* **docs:** resolve documentation deployment and broken links ([e78d7e8](https://github.com/juspay/neurolink/commit/e78d7e8da6ff16ee266a88beec70a26b67145da2))
+* **providers:** resolve ESLint errors and improve validation in Vertex AI health checker ([a5822ee](https://github.com/juspay/neurolink/commit/a5822eee3f8b6beaf3d2168ebb8888a6beaa5cb4))
 
-# [7.6.0](https://github.com/juspay/neurolink/compare/v7.5.0...v7.6.0) (2025-08-09)
+# [7.7.0](https://github.com/juspay/neurolink/compare/v7.6.1...v7.7.0) (2025-08-10)
+
+### Features
+
+- **tools:** add Lighthouse compatibility with unified registerTools API ([5200da2](https://github.com/juspay/neurolink/commit/5200da22b130b57c6b235346bd9db80970703900))
 
+## [7.6.1](https://github.com/juspay/neurolink/compare/v7.6.0...v7.6.1) (2025-08-09)
+
+### Bug Fixes
+
+- **docs:** resolve documentation deployment and broken links ([e78d7e8](https://github.com/juspay/neurolink/commit/e78d7e8da6ff16ee266a88beec70a26b67145da2))
+
+# [7.6.0](https://github.com/juspay/neurolink/compare/v7.5.0...v7.6.0) (2025-08-09)
 
 ### Features
 
-* **openai-compatible:** add OpenAI Compatible provider with intelligent model auto-discovery ([3041d26](https://github.com/juspay/neurolink/commit/3041d26fb33881e5962cb1f13d3d06f021f642f2))
+- **openai-compatible:** add OpenAI Compatible provider with intelligent model auto-discovery ([3041d26](https://github.com/juspay/neurolink/commit/3041d26fb33881e5962cb1f13d3d06f021f642f2))
 
 # [7.5.0](https://github.com/juspay/neurolink/compare/v7.4.0...v7.5.0) (2025-08-06)
 

package/README.md

@@ -45,6 +45,7 @@ npx @juspay/neurolink generate "Hello" --provider litellm --model "google/gemini
 - **🛡️ Error Recovery** - Graceful failures with provider fallback and retry logic
 - **📊 Analytics & Evaluation** - Built-in usage tracking and AI-powered quality assessment
 - **🔧 MCP Integration** - Model Context Protocol with 6 built-in tools and 58+ discoverable servers
+- **🚀 Lighthouse Integration** - Unified tool registration API supporting both object and array formats for seamless Lighthouse tool import
 
 ---
 
@@ -220,6 +221,53 @@ echo 'AWS_ACCESS_KEY_ID="your-aws-access-key"' >> .env
 npx @juspay/neurolink status
 ```
 
+### JSON Format Support (Complete)
+
+NeuroLink provides comprehensive JSON input/output support for both CLI and SDK:
+
+```bash
+# CLI JSON Output - Structured data for scripts
+npx @juspay/neurolink generate "Summary of AI trends" --format json
+npx @juspay/neurolink gen "Create a user profile" --format json --provider google-ai
+
+# Example JSON Output:
+{
+  "content": "AI trends include increased automation...",
+  "provider": "google-ai",
+  "model": "gemini-2.5-flash",
+  "usage": {
+    "promptTokens": 15,
+    "completionTokens": 127,
+    "totalTokens": 142
+  },
+  "responseTime": 1234
+}
+```
+
+```typescript
+// SDK JSON Input/Output - Full TypeScript support
+import { createBestAIProvider } from "@juspay/neurolink";
+
+const provider = createBestAIProvider();
+
+// Structured input
+const result = await provider.generate({
+  input: { text: "Create a product specification" },
+  schema: {
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      price: { type: "number" },
+      features: { type: "array", items: { type: "string" } },
+    },
+  },
+});
+
+// Access structured response
+const productData = JSON.parse(result.content);
+console.log(productData.name, productData.price, productData.features);
+```
+
 **📖 [Complete Setup Guide](./docs/PROVIDER-CONFIGURATION.md)** - All providers with detailed instructions
 
 ## ✨ Key Features
@@ -301,15 +349,42 @@ const result = await neurolink.generate({
   provider: "google-ai",
 });
 
-// Register multiple tools at once
+// Register multiple tools - Object format (existing)
 neurolink.registerTools({
   stockPrice: {
-    /* tool definition */
+    description: "Get stock price",
+    execute: async () => ({ price: 150.25 }),
   },
   calculator: {
-    /* tool definition */
+    description: "Calculate math",
+    execute: async () => ({ result: 42 }),
   },
 });
+
+// Register multiple tools - Array format (Lighthouse compatible)
+neurolink.registerTools([
+  {
+    name: "lighthouseTool1",
+    tool: {
+      description: "Lighthouse analytics tool",
+      parameters: z.object({
+        merchantId: z.string(),
+        dateRange: z.string().optional(),
+      }),
+      execute: async ({ merchantId, dateRange }) => {
+        // Lighthouse tool implementation with Zod schema
+        return { data: "analytics result" };
+      },
+    },
+  },
+  {
+    name: "lighthouseTool2",
+    tool: {
+      description: "Payment processing tool",
+      execute: async () => ({ status: "processed" }),
+    },
+  },
+]);
 ```
 
 ## 💰 Smart Model Selection

package/dist/cli/commands/config.d.ts

@@ -59,8 +59,8 @@ declare const ConfigSchema: z.ZodObject<{
             privateKey?: string | undefined;
         }, {
             model?: string | undefined;
-            location?: string | undefined;
             projectId?: string | undefined;
+            location?: string | undefined;
             credentials?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
@@ -199,8 +199,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         vertex?: {
             model?: string | undefined;
-            location?: string | undefined;
             projectId?: string | undefined;
+            location?: string | undefined;
             credentials?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
@@ -242,6 +242,9 @@ declare const ConfigSchema: z.ZodObject<{
         enableLogging: z.ZodDefault<z.ZodBoolean>;
         enableCaching: z.ZodDefault<z.ZodBoolean>;
         cacheStrategy: z.ZodDefault<z.ZodEnum<["memory", "file", "redis"]>>;
+        defaultEvaluationDomain: z.ZodOptional<z.ZodString>;
+        enableAnalyticsByDefault: z.ZodDefault<z.ZodBoolean>;
+        enableEvaluationByDefault: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         maxTokens: number;
         temperature: number;
@@ -249,6 +252,9 @@ declare const ConfigSchema: z.ZodObject<{
         enableLogging: boolean;
         enableCaching: boolean;
         cacheStrategy: "file" | "memory" | "redis";
+        enableAnalyticsByDefault: boolean;
+        enableEvaluationByDefault: boolean;
+        defaultEvaluationDomain?: string | undefined;
     }, {
         maxTokens?: number | undefined;
         temperature?: number | undefined;
@@ -256,6 +262,197 @@ declare const ConfigSchema: z.ZodObject<{
         enableLogging?: boolean | undefined;
         enableCaching?: boolean | undefined;
         cacheStrategy?: "file" | "memory" | "redis" | undefined;
+        defaultEvaluationDomain?: string | undefined;
+        enableAnalyticsByDefault?: boolean | undefined;
+        enableEvaluationByDefault?: boolean | undefined;
+    }>>;
+    domains: z.ZodDefault<z.ZodObject<{
+        healthcare: z.ZodDefault<z.ZodObject<{
+            evaluationCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            analyticsConfig: z.ZodDefault<z.ZodObject<{
+                trackPatientData: z.ZodDefault<z.ZodBoolean>;
+                trackDiagnosticAccuracy: z.ZodDefault<z.ZodBoolean>;
+                trackTreatmentOutcomes: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                trackPatientData: boolean;
+                trackDiagnosticAccuracy: boolean;
+                trackTreatmentOutcomes: boolean;
+            }, {
+                trackPatientData?: boolean | undefined;
+                trackDiagnosticAccuracy?: boolean | undefined;
+                trackTreatmentOutcomes?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackPatientData: boolean;
+                trackDiagnosticAccuracy: boolean;
+                trackTreatmentOutcomes: boolean;
+            };
+        }, {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackPatientData?: boolean | undefined;
+                trackDiagnosticAccuracy?: boolean | undefined;
+                trackTreatmentOutcomes?: boolean | undefined;
+            } | undefined;
+        }>>;
+        analytics: z.ZodDefault<z.ZodObject<{
+            evaluationCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            analyticsConfig: z.ZodDefault<z.ZodObject<{
+                trackDataQuality: z.ZodDefault<z.ZodBoolean>;
+                trackModelPerformance: z.ZodDefault<z.ZodBoolean>;
+                trackBusinessImpact: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                trackDataQuality: boolean;
+                trackModelPerformance: boolean;
+                trackBusinessImpact: boolean;
+            }, {
+                trackDataQuality?: boolean | undefined;
+                trackModelPerformance?: boolean | undefined;
+                trackBusinessImpact?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackDataQuality: boolean;
+                trackModelPerformance: boolean;
+                trackBusinessImpact: boolean;
+            };
+        }, {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackDataQuality?: boolean | undefined;
+                trackModelPerformance?: boolean | undefined;
+                trackBusinessImpact?: boolean | undefined;
+            } | undefined;
+        }>>;
+        finance: z.ZodDefault<z.ZodObject<{
+            evaluationCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            analyticsConfig: z.ZodDefault<z.ZodObject<{
+                trackRiskMetrics: z.ZodDefault<z.ZodBoolean>;
+                trackRegulatory: z.ZodDefault<z.ZodBoolean>;
+                trackPortfolioImpact: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                trackRiskMetrics: boolean;
+                trackRegulatory: boolean;
+                trackPortfolioImpact: boolean;
+            }, {
+                trackRiskMetrics?: boolean | undefined;
+                trackRegulatory?: boolean | undefined;
+                trackPortfolioImpact?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackRiskMetrics: boolean;
+                trackRegulatory: boolean;
+                trackPortfolioImpact: boolean;
+            };
+        }, {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackRiskMetrics?: boolean | undefined;
+                trackRegulatory?: boolean | undefined;
+                trackPortfolioImpact?: boolean | undefined;
+            } | undefined;
+        }>>;
+        ecommerce: z.ZodDefault<z.ZodObject<{
+            evaluationCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            analyticsConfig: z.ZodDefault<z.ZodObject<{
+                trackConversions: z.ZodDefault<z.ZodBoolean>;
+                trackUserBehavior: z.ZodDefault<z.ZodBoolean>;
+                trackRevenueImpact: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                trackConversions: boolean;
+                trackUserBehavior: boolean;
+                trackRevenueImpact: boolean;
+            }, {
+                trackConversions?: boolean | undefined;
+                trackUserBehavior?: boolean | undefined;
+                trackRevenueImpact?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackConversions: boolean;
+                trackUserBehavior: boolean;
+                trackRevenueImpact: boolean;
+            };
+        }, {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackConversions?: boolean | undefined;
+                trackUserBehavior?: boolean | undefined;
+                trackRevenueImpact?: boolean | undefined;
+            } | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        analytics: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackDataQuality: boolean;
+                trackModelPerformance: boolean;
+                trackBusinessImpact: boolean;
+            };
+        };
+        healthcare: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackPatientData: boolean;
+                trackDiagnosticAccuracy: boolean;
+                trackTreatmentOutcomes: boolean;
+            };
+        };
+        finance: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackRiskMetrics: boolean;
+                trackRegulatory: boolean;
+                trackPortfolioImpact: boolean;
+            };
+        };
+        ecommerce: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackConversions: boolean;
+                trackUserBehavior: boolean;
+                trackRevenueImpact: boolean;
+            };
+        };
+    }, {
+        analytics?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackDataQuality?: boolean | undefined;
+                trackModelPerformance?: boolean | undefined;
+                trackBusinessImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        healthcare?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackPatientData?: boolean | undefined;
+                trackDiagnosticAccuracy?: boolean | undefined;
+                trackTreatmentOutcomes?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        finance?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackRiskMetrics?: boolean | undefined;
+                trackRegulatory?: boolean | undefined;
+                trackPortfolioImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        ecommerce?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackConversions?: boolean | undefined;
+                trackUserBehavior?: boolean | undefined;
+                trackRevenueImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     providers: {
@@ -317,6 +514,43 @@ declare const ConfigSchema: z.ZodObject<{
         enableLogging: boolean;
         enableCaching: boolean;
         cacheStrategy: "file" | "memory" | "redis";
+        enableAnalyticsByDefault: boolean;
+        enableEvaluationByDefault: boolean;
+        defaultEvaluationDomain?: string | undefined;
+    };
+    domains: {
+        analytics: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackDataQuality: boolean;
+                trackModelPerformance: boolean;
+                trackBusinessImpact: boolean;
+            };
+        };
+        healthcare: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackPatientData: boolean;
+                trackDiagnosticAccuracy: boolean;
+                trackTreatmentOutcomes: boolean;
+            };
+        };
+        finance: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackRiskMetrics: boolean;
+                trackRegulatory: boolean;
+                trackPortfolioImpact: boolean;
+            };
+        };
+        ecommerce: {
+            evaluationCriteria: string[];
+            analyticsConfig: {
+                trackConversions: boolean;
+                trackUserBehavior: boolean;
+                trackRevenueImpact: boolean;
+            };
+        };
     };
 }, {
     providers?: {
@@ -334,8 +568,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         vertex?: {
             model?: string | undefined;
-            location?: string | undefined;
             projectId?: string | undefined;
+            location?: string | undefined;
             credentials?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
@@ -378,6 +612,43 @@ declare const ConfigSchema: z.ZodObject<{
         enableLogging?: boolean | undefined;
         enableCaching?: boolean | undefined;
         cacheStrategy?: "file" | "memory" | "redis" | undefined;
+        defaultEvaluationDomain?: string | undefined;
+        enableAnalyticsByDefault?: boolean | undefined;
+        enableEvaluationByDefault?: boolean | undefined;
+    } | undefined;
+    domains?: {
+        analytics?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackDataQuality?: boolean | undefined;
+                trackModelPerformance?: boolean | undefined;
+                trackBusinessImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        healthcare?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackPatientData?: boolean | undefined;
+                trackDiagnosticAccuracy?: boolean | undefined;
+                trackTreatmentOutcomes?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        finance?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackRiskMetrics?: boolean | undefined;
+                trackRegulatory?: boolean | undefined;
+                trackPortfolioImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        ecommerce?: {
+            evaluationCriteria?: string[] | undefined;
+            analyticsConfig?: {
+                trackConversions?: boolean | undefined;
+                trackUserBehavior?: boolean | undefined;
+                trackRevenueImpact?: boolean | undefined;
+            } | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export type NeuroLinkConfig = z.infer<typeof ConfigSchema>;
@@ -442,6 +713,7 @@ export declare class ConfigManager {
      * Mistral AI provider setup
      */
     private setupMistral;
+    /**
     /**
      * Get current configuration
      */

package/dist/cli/commands/config.js

@@ -114,6 +114,79 @@ const ConfigSchema = z.object({
         enableLogging: z.boolean().default(false),
         enableCaching: z.boolean().default(true),
         cacheStrategy: z.enum(["memory", "file", "redis"]).default("memory"),
+        defaultEvaluationDomain: z.string().optional(),
+        enableAnalyticsByDefault: z.boolean().default(false),
+        enableEvaluationByDefault: z.boolean().default(false),
+    })
+        .default({}),
+    domains: z
+        .object({
+        healthcare: z
+            .object({
+            evaluationCriteria: z
+                .array(z.string())
+                .default(["accuracy", "safety", "compliance", "clarity"]),
+            analyticsConfig: z
+                .object({
+                trackPatientData: z.boolean().default(false),
+                trackDiagnosticAccuracy: z.boolean().default(true),
+                trackTreatmentOutcomes: z.boolean().default(true),
+            })
+                .default({}),
+        })
+            .default({}),
+        analytics: z
+            .object({
+            evaluationCriteria: z
+                .array(z.string())
+                .default(["accuracy", "relevance", "completeness", "insight"]),
+            analyticsConfig: z
+                .object({
+                trackDataQuality: z.boolean().default(true),
+                trackModelPerformance: z.boolean().default(true),
+                trackBusinessImpact: z.boolean().default(true),
+            })
+                .default({}),
+        })
+            .default({}),
+        finance: z
+            .object({
+            evaluationCriteria: z
+                .array(z.string())
+                .default([
+                "accuracy",
+                "risk-awareness",
+                "compliance",
+                "timeliness",
+            ]),
+            analyticsConfig: z
+                .object({
+                trackRiskMetrics: z.boolean().default(true),
+                trackRegulatory: z.boolean().default(true),
+                trackPortfolioImpact: z.boolean().default(false),
+            })
+                .default({}),
+        })
+            .default({}),
+        ecommerce: z
+            .object({
+            evaluationCriteria: z
+                .array(z.string())
+                .default([
+                "conversion-potential",
+                "user-experience",
+                "revenue-impact",
+                "practicality",
+            ]),
+            analyticsConfig: z
+                .object({
+                trackConversions: z.boolean().default(true),
+                trackUserBehavior: z.boolean().default(true),
+                trackRevenueImpact: z.boolean().default(true),
+            })
+                .default({}),
+        })
+            .default({}),
     })
         .default({}),
 });
@@ -208,6 +281,31 @@ export class ConfigManager {
                     default: this.config.preferences.temperature,
                     validate: (value) => value >= 0 && value <= 2,
                 },
+                {
+                    type: "list",
+                    name: "defaultEvaluationDomain",
+                    message: "Default evaluation domain (optional):",
+                    choices: [
+                        { name: "None (manual selection)", value: undefined },
+                        { name: "Healthcare", value: "healthcare" },
+                        { name: "Analytics", value: "analytics" },
+                        { name: "Finance", value: "finance" },
+                        { name: "E-commerce", value: "ecommerce" },
+                    ],
+                    default: this.config.preferences.defaultEvaluationDomain,
+                },
+                {
+                    type: "confirm",
+                    name: "enableAnalyticsByDefault",
+                    message: "Enable analytics by default?",
+                    default: this.config.preferences.enableAnalyticsByDefault,
+                },
+                {
+                    type: "confirm",
+                    name: "enableEvaluationByDefault",
+                    message: "Enable evaluation by default?",
+                    default: this.config.preferences.enableEvaluationByDefault,
+                },
                 {
                     type: "confirm",
                     name: "setupProviders",
@@ -219,6 +317,12 @@ export class ConfigManager {
             this.config.defaultProvider = preferences.defaultProvider;
             this.config.preferences.outputFormat = preferences.outputFormat;
             this.config.preferences.temperature = preferences.temperature;
+            this.config.preferences.defaultEvaluationDomain =
+                preferences.defaultEvaluationDomain;
+            this.config.preferences.enableAnalyticsByDefault =
+                preferences.enableAnalyticsByDefault;
+            this.config.preferences.enableEvaluationByDefault =
+                preferences.enableEvaluationByDefault;
             // Setup providers if requested
             if (preferences.setupProviders) {
                 await this.setupProviders();
@@ -622,6 +726,7 @@ export class ConfigManager {
         ]);
         this.config.providers.mistral = answers;
     }
+    /**
     /**
      * Get current configuration
      */
@@ -645,6 +750,9 @@ export class ConfigManager {
         logger.always(`  Output Format: ${chalk.white(this.config.preferences.outputFormat)}`);
         logger.always(`  Temperature: ${chalk.white(this.config.preferences.temperature)}`);
         logger.always(`  Max Tokens: ${chalk.white(this.config.preferences.maxTokens)}`);
+        logger.always(`  Default Evaluation Domain: ${chalk.white(this.config.preferences.defaultEvaluationDomain || "None")}`);
+        logger.always(`  Analytics by Default: ${chalk.white(this.config.preferences.enableAnalyticsByDefault)}`);
+        logger.always(`  Evaluation by Default: ${chalk.white(this.config.preferences.enableEvaluationByDefault)}`);
         logger.always(chalk.cyan("\nConfigured Providers:"));
         Object.entries(this.config.providers).forEach(([name, config]) => {
             if (config && Object.keys(config).length > 0) {
@@ -654,6 +762,19 @@ export class ConfigManager {
                 }
             }
         });
+        logger.always(chalk.cyan("\nConfigured Domains:"));
+        Object.entries(this.config.domains).forEach(([name, config]) => {
+            if (config && Object.keys(config).length > 0) {
+                logger.always(`  ${chalk.green("✅")} ${name.toUpperCase()}`);
+                if (config.evaluationCriteria && config.evaluationCriteria.length > 0) {
+                    logger.always(`    Evaluation Criteria: ${chalk.white(config.evaluationCriteria.join(", "))}`);
+                }
+                if (config.analyticsConfig) {
+                    const analyticsEnabled = Object.values(config.analyticsConfig).some(Boolean);
+                    logger.always(`    Analytics: ${chalk.white(analyticsEnabled ? "Configured" : "Disabled")}`);
+                }
+            }
+        });
         logger.always(chalk.cyan("\nConfiguration File:"));
         logger.always(`  Location: ${chalk.white(this.configFile)}`);
     }