@juspay/neurolink 1.6.0 → 1.9.0

package/dist/agent/direct-tools.js

@@ -0,0 +1,387 @@
+/**
+ * Direct Tool Definitions for NeuroLink CLI Agent
+ * Simple, reliable tools that work immediately with Vercel AI SDK
+ */
+import { tool } from "ai";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Direct tool definitions that work immediately with Gemini/AI SDK
+ * These bypass MCP complexity and provide reliable agent functionality
+ */
+export const directAgentTools = {
+    getCurrentTime: tool({
+        description: "Get the current date and time",
+        parameters: z.object({
+            timezone: z
+                .string()
+                .optional()
+                .describe('Timezone (e.g., "America/New_York", "Asia/Kolkata"). Defaults to local time.'),
+        }),
+        execute: async ({ timezone }) => {
+            try {
+                const now = new Date();
+                if (timezone) {
+                    return {
+                        success: true,
+                        time: now.toLocaleString("en-US", { timeZone: timezone }),
+                        timezone: timezone,
+                        iso: now.toISOString(),
+                    };
+                }
+                return {
+                    success: true,
+                    time: now.toLocaleString(),
+                    iso: now.toISOString(),
+                    timestamp: now.getTime(),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    }),
+    readFile: tool({
+        description: "Read the contents of a file from the filesystem",
+        parameters: z.object({
+            path: z.string().describe("File path to read (relative or absolute)"),
+        }),
+        execute: async ({ path: filePath }) => {
+            try {
+                // Security check - prevent reading outside current directory for relative paths
+                const resolvedPath = path.resolve(filePath);
+                const cwd = process.cwd();
+                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
+                    return {
+                        success: false,
+                        error: `Access denied: Cannot read files outside current directory`,
+                    };
+                }
+                const content = fs.readFileSync(resolvedPath, "utf-8");
+                const stats = fs.statSync(resolvedPath);
+                return {
+                    success: true,
+                    content,
+                    size: stats.size,
+                    path: resolvedPath,
+                    lastModified: stats.mtime.toISOString(),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    path: filePath,
+                };
+            }
+        },
+    }),
+    listDirectory: tool({
+        description: "List files and directories in a specified directory",
+        parameters: z.object({
+            path: z
+                .string()
+                .describe("Directory path to list (relative or absolute)"),
+            includeHidden: z
+                .boolean()
+                .optional()
+                .describe("Include hidden files (starting with .)")
+                .default(false),
+        }),
+        execute: async ({ path: dirPath, includeHidden }) => {
+            try {
+                const resolvedPath = path.resolve(dirPath);
+                const items = fs.readdirSync(resolvedPath);
+                const filteredItems = includeHidden
+                    ? items
+                    : items.filter((item) => !item.startsWith("."));
+                const itemDetails = filteredItems.map((item) => {
+                    const itemPath = path.join(resolvedPath, item);
+                    const stats = fs.statSync(itemPath);
+                    return {
+                        name: item,
+                        type: stats.isDirectory() ? "directory" : "file",
+                        size: stats.isFile() ? stats.size : undefined,
+                        lastModified: stats.mtime.toISOString(),
+                    };
+                });
+                return {
+                    success: true,
+                    path: resolvedPath,
+                    items: itemDetails,
+                    count: itemDetails.length,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    path: dirPath,
+                };
+            }
+        },
+    }),
+    calculateMath: tool({
+        description: "Perform mathematical calculations safely",
+        parameters: z.object({
+            expression: z
+                .string()
+                .describe('Mathematical expression to evaluate (e.g., "2 + 2", "Math.sqrt(16)")'),
+            precision: z
+                .number()
+                .optional()
+                .describe("Number of decimal places for result")
+                .default(2),
+        }),
+        execute: async ({ expression, precision }) => {
+            try {
+                // Simple safe evaluation - only allow basic math operations
+                const sanitizedExpression = expression.replace(/[^0-9+\-*/().\s]/g, "");
+                if (sanitizedExpression !== expression) {
+                    // Try Math functions for more complex operations
+                    const allowedMathFunctions = [
+                        "Math.abs",
+                        "Math.ceil",
+                        "Math.floor",
+                        "Math.round",
+                        "Math.sqrt",
+                        "Math.pow",
+                        "Math.sin",
+                        "Math.cos",
+                        "Math.tan",
+                        "Math.log",
+                        "Math.exp",
+                        "Math.PI",
+                        "Math.E",
+                    ];
+                    let safeExpression = expression;
+                    for (const func of allowedMathFunctions) {
+                        safeExpression = safeExpression.replace(new RegExp(func, "g"), func);
+                    }
+                    // Remove any remaining non-safe characters except Math functions
+                    const mathSafe = /^[0-9+\-*/().\s]|Math\.(abs|ceil|floor|round|sqrt|pow|sin|cos|tan|log|exp|PI|E)/g;
+                    if (!safeExpression
+                        .split("")
+                        .every((char) => mathSafe.test(char) ||
+                        char === "(" ||
+                        char === ")" ||
+                        char === "," ||
+                        char === " ")) {
+                        return {
+                            success: false,
+                            error: `Unsafe expression: Only basic math operations and Math functions are allowed`,
+                        };
+                    }
+                }
+                // Use Function constructor for safe evaluation
+                const result = new Function(`'use strict'; return (${expression})`)();
+                const roundedResult = typeof result === "number"
+                    ? Number(result.toFixed(precision))
+                    : result;
+                return {
+                    success: true,
+                    expression,
+                    result: roundedResult,
+                    type: typeof result,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    expression,
+                };
+            }
+        },
+    }),
+    writeFile: tool({
+        description: "Write content to a file (use with caution)",
+        parameters: z.object({
+            path: z.string().describe("File path to write to"),
+            content: z.string().describe("Content to write to the file"),
+            mode: z
+                .enum(["create", "overwrite", "append"])
+                .default("create")
+                .describe("Write mode"),
+        }),
+        execute: async ({ path: filePath, content, mode }) => {
+            try {
+                const resolvedPath = path.resolve(filePath);
+                const cwd = process.cwd();
+                // Security check
+                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
+                    return {
+                        success: false,
+                        error: `Access denied: Cannot write files outside current directory`,
+                    };
+                }
+                // Check if file exists for create mode
+                if (mode === "create" && fs.existsSync(resolvedPath)) {
+                    return {
+                        success: false,
+                        error: `File already exists. Use 'overwrite' or 'append' mode to modify existing files.`,
+                    };
+                }
+                let finalContent = content;
+                if (mode === "append" && fs.existsSync(resolvedPath)) {
+                    const existingContent = fs.readFileSync(resolvedPath, "utf-8");
+                    finalContent = existingContent + content;
+                }
+                fs.writeFileSync(resolvedPath, finalContent, "utf-8");
+                const stats = fs.statSync(resolvedPath);
+                return {
+                    success: true,
+                    path: resolvedPath,
+                    mode,
+                    size: stats.size,
+                    written: content.length,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    path: filePath,
+                };
+            }
+        },
+    }),
+    searchFiles: tool({
+        description: "Search for files by name pattern in a directory",
+        parameters: z.object({
+            directory: z.string().describe("Directory to search in"),
+            pattern: z
+                .string()
+                .describe("File name pattern to search for (supports wildcards like *.js)"),
+            recursive: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Search recursively in subdirectories"),
+        }),
+        execute: async ({ directory, pattern, recursive }) => {
+            try {
+                const resolvedDir = path.resolve(directory);
+                if (!fs.existsSync(resolvedDir)) {
+                    return {
+                        success: false,
+                        error: `Directory does not exist: ${resolvedDir}`,
+                    };
+                }
+                const matches = [];
+                const searchDir = (dir, depth = 0) => {
+                    if (!recursive && depth > 0) {
+                        return;
+                    }
+                    const items = fs.readdirSync(dir);
+                    for (const item of items) {
+                        const itemPath = path.join(dir, item);
+                        const stats = fs.statSync(itemPath);
+                        if (stats.isDirectory()) {
+                            if (recursive && depth < 10) {
+                                // Prevent infinite recursion
+                                searchDir(itemPath, depth + 1);
+                            }
+                        }
+                        else if (stats.isFile()) {
+                            // Simple pattern matching (convert * to regex)
+                            const regexPattern = pattern
+                                .replace(/\*/g, ".*")
+                                .replace(/\?/g, ".");
+                            const regex = new RegExp(`^${regexPattern}$`, "i");
+                            if (regex.test(item)) {
+                                matches.push({
+                                    name: item,
+                                    path: itemPath,
+                                    size: stats.size,
+                                    lastModified: stats.mtime.toISOString(),
+                                });
+                            }
+                        }
+                    }
+                };
+                searchDir(resolvedDir);
+                return {
+                    success: true,
+                    directory: resolvedDir,
+                    pattern,
+                    matches,
+                    count: matches.length,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    directory,
+                    pattern,
+                };
+            }
+        },
+    }),
+};
+/**
+ * Get a subset of tools for specific use cases
+ */
+export function getToolsForCategory(category = "all") {
+    switch (category) {
+        case "basic":
+            return {
+                getCurrentTime: directAgentTools.getCurrentTime,
+                calculateMath: directAgentTools.calculateMath,
+            };
+        case "filesystem":
+            return {
+                readFile: directAgentTools.readFile,
+                listDirectory: directAgentTools.listDirectory,
+                writeFile: directAgentTools.writeFile,
+                searchFiles: directAgentTools.searchFiles,
+            };
+        case "utility":
+            return {
+                getCurrentTime: directAgentTools.getCurrentTime,
+                calculateMath: directAgentTools.calculateMath,
+                listDirectory: directAgentTools.listDirectory,
+            };
+        case "all":
+        default:
+            return directAgentTools;
+    }
+}
+/**
+ * Get tool names for validation
+ */
+export function getAvailableToolNames() {
+    return Object.keys(directAgentTools);
+}
+/**
+ * Validate that all tools have proper structure
+ */
+export function validateToolStructure() {
+    try {
+        for (const [name, tool] of Object.entries(directAgentTools)) {
+            if (!tool.description || typeof tool.description !== "string") {
+                console.error(`❌ Tool ${name} missing description`);
+                return false;
+            }
+            if (!tool.parameters) {
+                console.error(`❌ Tool ${name} missing parameters`);
+                return false;
+            }
+            if (!tool.execute || typeof tool.execute !== "function") {
+                console.error(`❌ Tool ${name} missing execute function`);
+                return false;
+            }
+        }
+        console.log("✅ All tools have valid structure");
+        return true;
+    }
+    catch (error) {
+        console.error("❌ Tool validation failed:", error);
+        return false;
+    }
+}

package/dist/cli/commands/agent-generate.d.ts

@@ -0,0 +1,2 @@
+import type { CommandModule } from "yargs";
+export declare const agentGenerateCommand: CommandModule;

package/dist/cli/commands/agent-generate.js

@@ -0,0 +1,70 @@
+import { AgentEnhancedProvider } from "../../lib/providers/agent-enhanced-provider.js";
+import ora from "ora";
+import chalk from "chalk";
+export const agentGenerateCommand = {
+    command: "agent-generate <prompt>",
+    describe: "Generate text with agent capabilities (tool calling)",
+    builder: (yargs) => yargs
+        .positional("prompt", {
+        describe: "The prompt for the agent",
+        type: "string",
+    })
+        .option("provider", {
+        alias: "p",
+        describe: "The AI provider to use",
+        type: "string",
+        choices: ["google-ai", "openai", "anthropic"],
+        default: "google-ai",
+    })
+        .option("model", {
+        alias: "m",
+        describe: "The model to use",
+        type: "string",
+    })
+        .option("toolCategory", {
+        alias: "t",
+        describe: "The category of tools to use",
+        type: "string",
+        choices: ["basic", "filesystem", "utility", "all"],
+        default: "all",
+    }),
+    handler: async (argv) => {
+        const { prompt, provider, model, toolCategory } = argv;
+        const spinner = ora(`Generating response with ${provider} agent...`).start();
+        try {
+            const agentProvider = new AgentEnhancedProvider({
+                provider,
+                model,
+                toolCategory,
+            });
+            const result = await agentProvider.generateText(prompt);
+            if (result) {
+                spinner.succeed("Response generated successfully!");
+                console.log(chalk.green("\nAI Response:"));
+                console.log(result.text);
+                if (result.toolCalls && result.toolCalls.length > 0) {
+                    console.log(chalk.yellow("\nTools Called:"));
+                    for (const call of result.toolCalls) {
+                        console.log(`- ${call.toolName}`);
+                        console.log(`  Args: ${JSON.stringify(call.args)}`);
+                    }
+                }
+                if (result.toolResults && result.toolResults.length > 0) {
+                    console.log(chalk.blue("\nTool Results:"));
+                    for (const toolResult of result.toolResults) {
+                        console.log(`- ${toolResult.toolName}`);
+                        console.log(`  Result: ${JSON.stringify(toolResult.result)}`);
+                    }
+                }
+            }
+            else {
+                spinner.fail("Failed to generate response.");
+            }
+        }
+        catch (error) {
+            spinner.fail("An error occurred during generation.");
+            console.error(chalk.red(error));
+            process.exit(1);
+        }
+    },
+};

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

@@ -5,7 +5,7 @@
  * Enhanced configuration system with interactive setup,
  * multi-profile support, and smart validation.
  */
-import { z } from 'zod';
+import { z } from "zod";
 declare const ConfigSchema: z.ZodObject<{
     defaultProvider: z.ZodDefault<z.ZodEnum<["auto", "openai", "bedrock", "vertex", "anthropic", "azure", "google-ai", "huggingface", "ollama", "mistral"]>>;
     providers: z.ZodDefault<z.ZodObject<{
@@ -92,7 +92,7 @@ declare const ConfigSchema: z.ZodObject<{
             endpoint?: string | undefined;
             deploymentId?: string | undefined;
         }>>;
-        'google-ai': z.ZodOptional<z.ZodObject<{
+        "google-ai": z.ZodOptional<z.ZodObject<{
             apiKey: z.ZodOptional<z.ZodString>;
             model: z.ZodDefault<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
@@ -167,7 +167,7 @@ declare const ConfigSchema: z.ZodObject<{
             endpoint?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
-        'google-ai'?: {
+        "google-ai"?: {
             model: string;
             apiKey?: string | undefined;
         } | undefined;
@@ -216,7 +216,7 @@ declare const ConfigSchema: z.ZodObject<{
             endpoint?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
-        'google-ai'?: {
+        "google-ai"?: {
             model?: string | undefined;
             apiKey?: string | undefined;
         } | undefined;
@@ -291,7 +291,7 @@ declare const ConfigSchema: z.ZodObject<{
             endpoint?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
-        'google-ai'?: {
+        "google-ai"?: {
             model: string;
             apiKey?: string | undefined;
         } | undefined;
@@ -352,7 +352,7 @@ declare const ConfigSchema: z.ZodObject<{
             endpoint?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
-        'google-ai'?: {
+        "google-ai"?: {
             model?: string | undefined;
             apiKey?: string | undefined;
         } | undefined;