@wingman-ai/gateway 0.1.0

package/dist/agent/tests/toolRegistry.test.js

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { createTool, createTools, getAvailableTools } from "../config/toolRegistry.js";
+describe("Tool Registry", ()=>{
+    describe("createTool", ()=>{
+        it("should create internet_search tool", ()=>{
+            const tool = createTool("internet_search");
+            expect(tool).not.toBeNull();
+            expect(tool?.name).toBe("internet_search");
+        });
+        it("should create web_crawler tool", ()=>{
+            const tool = createTool("web_crawler");
+            expect(tool).not.toBeNull();
+            expect(tool?.name).toBe("web_crawler");
+        });
+        it("should create command_execute tool with default options", ()=>{
+            const tool = createTool("command_execute");
+            expect(tool).not.toBeNull();
+            expect(tool?.name).toBe("command_execute");
+        });
+        it("should create command_execute tool with custom options", ()=>{
+            const tool = createTool("command_execute", {
+                workspace: "/custom/path",
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: false,
+                timeout: 60000
+            });
+            expect(tool).not.toBeNull();
+            expect(tool?.name).toBe("command_execute");
+        });
+        it("should create think tool", ()=>{
+            const tool = createTool("think");
+            expect(tool).not.toBeNull();
+            expect(tool?.name).toBe("think");
+        });
+        it("should return null for unknown tool name", ()=>{
+            const tool = createTool("unknown_tool");
+            expect(tool).toBeNull();
+        });
+    });
+    describe("createTools", ()=>{
+        it("should create multiple tools from array", async ()=>{
+            const tools = await createTools([
+                "internet_search",
+                "web_crawler",
+                "think"
+            ]);
+            expect(tools).toHaveLength(3);
+            expect(tools[0].name).toBe("internet_search");
+            expect(tools[1].name).toBe("web_crawler");
+            expect(tools[2].name).toBe("think");
+        });
+        it("should create empty array for empty input", async ()=>{
+            const tools = await createTools([]);
+            expect(tools).toHaveLength(0);
+        });
+        it("should skip unknown tool names", async ()=>{
+            const tools = await createTools([
+                "internet_search",
+                "unknown_tool",
+                "think"
+            ]);
+            expect(tools).toHaveLength(2);
+            expect(tools[0].name).toBe("internet_search");
+            expect(tools[1].name).toBe("think");
+        });
+        it("should pass options to all tools", async ()=>{
+            const tools = await createTools([
+                "command_execute"
+            ], {
+                workspace: "/test/path",
+                timeout: 30000
+            });
+            expect(tools).toHaveLength(1);
+            expect(tools[0].name).toBe("command_execute");
+        });
+        it("should create all available tools", async ()=>{
+            const availableTools = getAvailableTools();
+            const tools = await createTools(availableTools);
+            expect(tools).toHaveLength(availableTools.length);
+        });
+    });
+    describe("getAvailableTools", ()=>{
+        it("should return all available tool names", ()=>{
+            const tools = getAvailableTools();
+            expect(tools).toEqual([
+                "internet_search",
+                "web_crawler",
+                "command_execute",
+                "think",
+                "code_search",
+                "git_status"
+            ]);
+        });
+        it("should return a consistent list", ()=>{
+            const tools1 = getAvailableTools();
+            const tools2 = getAvailableTools();
+            expect(tools1).toEqual(tools2);
+        });
+    });
+});

package/dist/agent/tools/code_search.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCodeSearchTool: ()=>createCodeSearchTool
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_node_child_process_namespaceObject = require("node:child_process");
+function isRipgrepAvailable() {
+    try {
+        (0, external_node_child_process_namespaceObject.execSync)("rg --version", {
+            stdio: "ignore"
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+const createCodeSearchTool = (workspace)=>{
+    const useRipgrep = isRipgrepAvailable();
+    return (0, external_langchain_namespaceObject.tool)(async ({ pattern, path, type, context = 2, caseSensitive = false })=>new Promise((resolve)=>{
+            try {
+                let command;
+                let args = [];
+                if (useRipgrep) {
+                    command = "rg";
+                    if (context > 0) args.push("-C", String(context));
+                    if (!caseSensitive) args.push("-i");
+                    args.push("-n");
+                    if (type) args.push("-t", type);
+                    args.push(pattern);
+                    if (path) args.push(path);
+                    else args.push(".");
+                } else {
+                    command = "grep";
+                    args.push("-r");
+                    args.push("-n");
+                    if (context > 0) args.push("-C", String(context));
+                    if (!caseSensitive) args.push("-i");
+                    if (type) args.push("--include", `*.${type}`);
+                    args.push(pattern);
+                    if (path) args.push(path);
+                    else args.push(".");
+                }
+                const proc = (0, external_node_child_process_namespaceObject.spawn)(command, args, {
+                    cwd: workspace,
+                    shell: false
+                });
+                let output = "";
+                let errorOutput = "";
+                proc.stdout.on("data", (data)=>{
+                    output += data.toString();
+                });
+                proc.stderr.on("data", (data)=>{
+                    errorOutput += data.toString();
+                });
+                proc.on("close", (code)=>{
+                    if (0 === code) resolve(output || "No matches found");
+                    else 1 === code ? resolve("No matches found") : resolve(`Error searching code: ${errorOutput || "Unknown error"}`);
+                });
+                proc.on("error", (err)=>{
+                    resolve(`Failed to execute ${command}: ${err.message}`);
+                });
+            } catch (error) {
+                resolve(`Error in code search: ${error}`);
+            }
+        }), {
+        name: "code_search",
+        description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
+        schema: external_zod_namespaceObject.z.object({
+            pattern: external_zod_namespaceObject.z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
+            path: external_zod_namespaceObject.z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to entire workspace."),
+            type: external_zod_namespaceObject.z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
+            context: external_zod_namespaceObject.z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
+            caseSensitive: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
+        })
+    });
+};
+exports.createCodeSearchTool = __webpack_exports__.createCodeSearchTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCodeSearchTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tools/code_search.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/**
+ * Creates a tool that searches code using ripgrep (or grep as fallback)
+ * This provides fast, structured code search across the codebase
+ */
+export declare const createCodeSearchTool: (workspace: string) => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    pattern: string;
+    path?: string;
+    type?: string;
+    context?: number;
+    caseSensitive?: boolean;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    type?: string | undefined;
+    context?: number | undefined;
+    caseSensitive?: boolean | undefined;
+}, string, "code_search">;

package/dist/agent/tools/code_search.js

@@ -0,0 +1,74 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import { execSync, spawn } from "node:child_process";
+function isRipgrepAvailable() {
+    try {
+        execSync("rg --version", {
+            stdio: "ignore"
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+const createCodeSearchTool = (workspace)=>{
+    const useRipgrep = isRipgrepAvailable();
+    return tool(async ({ pattern, path, type, context = 2, caseSensitive = false })=>new Promise((resolve)=>{
+            try {
+                let command;
+                let args = [];
+                if (useRipgrep) {
+                    command = "rg";
+                    if (context > 0) args.push("-C", String(context));
+                    if (!caseSensitive) args.push("-i");
+                    args.push("-n");
+                    if (type) args.push("-t", type);
+                    args.push(pattern);
+                    if (path) args.push(path);
+                    else args.push(".");
+                } else {
+                    command = "grep";
+                    args.push("-r");
+                    args.push("-n");
+                    if (context > 0) args.push("-C", String(context));
+                    if (!caseSensitive) args.push("-i");
+                    if (type) args.push("--include", `*.${type}`);
+                    args.push(pattern);
+                    if (path) args.push(path);
+                    else args.push(".");
+                }
+                const proc = spawn(command, args, {
+                    cwd: workspace,
+                    shell: false
+                });
+                let output = "";
+                let errorOutput = "";
+                proc.stdout.on("data", (data)=>{
+                    output += data.toString();
+                });
+                proc.stderr.on("data", (data)=>{
+                    errorOutput += data.toString();
+                });
+                proc.on("close", (code)=>{
+                    if (0 === code) resolve(output || "No matches found");
+                    else 1 === code ? resolve("No matches found") : resolve(`Error searching code: ${errorOutput || "Unknown error"}`);
+                });
+                proc.on("error", (err)=>{
+                    resolve(`Failed to execute ${command}: ${err.message}`);
+                });
+            } catch (error) {
+                resolve(`Error in code search: ${error}`);
+            }
+        }), {
+        name: "code_search",
+        description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
+        schema: z.object({
+            pattern: z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
+            path: z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to entire workspace."),
+            type: z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
+            context: z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
+            caseSensitive: z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
+        })
+    });
+};
+export { createCodeSearchTool };

package/dist/agent/tools/command_execute.cjs

@@ -0,0 +1,136 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCommandExecuteTool: ()=>createCommandExecuteTool,
+    DEFAULT_BLOCKED_COMMANDS: ()=>DEFAULT_BLOCKED_COMMANDS
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const DEFAULT_BLOCKED_COMMANDS = [
+    "rm",
+    "remove",
+    "del",
+    "delete",
+    "rmdir",
+    "rd",
+    "mv",
+    "move",
+    "format",
+    ">",
+    ">>",
+    "chmod",
+    "chown",
+    ":>",
+    "sudo",
+    "su"
+];
+const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000)=>(0, external_langchain_namespaceObject.tool)(async ({ command })=>new Promise((resolve)=>{
+            try {
+                const commandParts = command.trim().split(/\s+/);
+                const commandName = (commandParts[0] || "").toLowerCase();
+                const baseCommand = commandName.split(/[\\/]/).pop() || "";
+                if (blockedCommands.includes(baseCommand)) {
+                    const result = `Command: "${command}" rejected, contains potentially destructive operations`;
+                    resolve(result);
+                    return;
+                }
+                if (!allowScriptExecution && (commandName.endsWith(".sh") || commandName.endsWith(".bash") || commandName.endsWith(".zsh") || commandName.endsWith(".ps1") || commandName.endsWith(".cmd") || commandName.endsWith(".bat"))) {
+                    const result = `Command: "${command}" rejected, script execution not allowed`;
+                    resolve(result);
+                    return;
+                }
+                let output = "";
+                let hasExited = false;
+                const { NODE_OPTIONS, NODE_DEBUG, VSCODE_INSPECTOR_OPTIONS, ...cleanEnv } = process.env;
+                const safeEnv = {
+                    ...cleanEnv,
+                    FORCE_COLOR: "0",
+                    NO_COLOR: "1",
+                    GIT_PAGER: "cat",
+                    ...envVariables ?? {}
+                };
+                const terminalProcess = (0, external_node_child_process_namespaceObject.spawn)(command, [], {
+                    cwd: workspace,
+                    shell: true,
+                    stdio: [
+                        "ignore",
+                        "pipe",
+                        "pipe"
+                    ],
+                    env: safeEnv,
+                    windowsHide: true
+                });
+                const timeout = setTimeout(()=>{
+                    if (!hasExited) {
+                        hasExited = true;
+                        try {
+                            terminalProcess.kill();
+                        } catch (e) {}
+                        const result = `Command: "${command}" timed out after ${timeoutInMilliseconds / 1000} seconds`;
+                        resolve(result);
+                    }
+                }, timeoutInMilliseconds);
+                const resolveResponse = (result, failed)=>{
+                    if (!hasExited) {
+                        hasExited = true;
+                        clearTimeout(timeout);
+                        const prefix = failed ? `Command: "${command}" failed with output:` : `Command: "${command}" completed successfully with output:`;
+                        resolve(result ? `${prefix}\n${result}` : prefix);
+                    }
+                };
+                terminalProcess.stdout?.on("data", (data)=>{
+                    output += data.toString();
+                });
+                terminalProcess.stderr?.on("data", (data)=>{
+                    output += data.toString();
+                });
+                terminalProcess.on("error", (err)=>{
+                    resolveResponse(err.message, true);
+                });
+                terminalProcess.on("exit", (code)=>{
+                    resolveResponse(output, 0 !== code);
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                resolve(`Error: ${errorMessage}`);
+            }
+        }), {
+        name: "command_execute",
+        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the workspace context.",
+        schema: external_zod_namespaceObject.z.object({
+            command: external_zod_namespaceObject.z.string().describe("The command to execute in the terminal")
+        })
+    });
+exports.DEFAULT_BLOCKED_COMMANDS = __webpack_exports__.DEFAULT_BLOCKED_COMMANDS;
+exports.createCommandExecuteTool = __webpack_exports__.createCommandExecuteTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_BLOCKED_COMMANDS",
+    "createCommandExecuteTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tools/command_execute.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const DEFAULT_BLOCKED_COMMANDS: string[];
+/**
+ * Creates a tool that executes terminal commands safely
+ */
+export declare const createCommandExecuteTool: (workspace: string, envVariables?: Record<string, string>, blockedCommands?: string[], allowScriptExecution?: boolean, timeoutInMilliseconds?: number) => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    command: z.ZodString;
+}, z.core.$strip>, {
+    command: string;
+}, {
+    command: string;
+}, string, "command_execute">;

package/dist/agent/tools/command_execute.js

@@ -0,0 +1,99 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+const DEFAULT_BLOCKED_COMMANDS = [
+    "rm",
+    "remove",
+    "del",
+    "delete",
+    "rmdir",
+    "rd",
+    "mv",
+    "move",
+    "format",
+    ">",
+    ">>",
+    "chmod",
+    "chown",
+    ":>",
+    "sudo",
+    "su"
+];
+const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000)=>tool(async ({ command })=>new Promise((resolve)=>{
+            try {
+                const commandParts = command.trim().split(/\s+/);
+                const commandName = (commandParts[0] || "").toLowerCase();
+                const baseCommand = commandName.split(/[\\/]/).pop() || "";
+                if (blockedCommands.includes(baseCommand)) {
+                    const result = `Command: "${command}" rejected, contains potentially destructive operations`;
+                    resolve(result);
+                    return;
+                }
+                if (!allowScriptExecution && (commandName.endsWith(".sh") || commandName.endsWith(".bash") || commandName.endsWith(".zsh") || commandName.endsWith(".ps1") || commandName.endsWith(".cmd") || commandName.endsWith(".bat"))) {
+                    const result = `Command: "${command}" rejected, script execution not allowed`;
+                    resolve(result);
+                    return;
+                }
+                let output = "";
+                let hasExited = false;
+                const { NODE_OPTIONS, NODE_DEBUG, VSCODE_INSPECTOR_OPTIONS, ...cleanEnv } = process.env;
+                const safeEnv = {
+                    ...cleanEnv,
+                    FORCE_COLOR: "0",
+                    NO_COLOR: "1",
+                    GIT_PAGER: "cat",
+                    ...envVariables ?? {}
+                };
+                const terminalProcess = spawn(command, [], {
+                    cwd: workspace,
+                    shell: true,
+                    stdio: [
+                        "ignore",
+                        "pipe",
+                        "pipe"
+                    ],
+                    env: safeEnv,
+                    windowsHide: true
+                });
+                const timeout = setTimeout(()=>{
+                    if (!hasExited) {
+                        hasExited = true;
+                        try {
+                            terminalProcess.kill();
+                        } catch (e) {}
+                        const result = `Command: "${command}" timed out after ${timeoutInMilliseconds / 1000} seconds`;
+                        resolve(result);
+                    }
+                }, timeoutInMilliseconds);
+                const resolveResponse = (result, failed)=>{
+                    if (!hasExited) {
+                        hasExited = true;
+                        clearTimeout(timeout);
+                        const prefix = failed ? `Command: "${command}" failed with output:` : `Command: "${command}" completed successfully with output:`;
+                        resolve(result ? `${prefix}\n${result}` : prefix);
+                    }
+                };
+                terminalProcess.stdout?.on("data", (data)=>{
+                    output += data.toString();
+                });
+                terminalProcess.stderr?.on("data", (data)=>{
+                    output += data.toString();
+                });
+                terminalProcess.on("error", (err)=>{
+                    resolveResponse(err.message, true);
+                });
+                terminalProcess.on("exit", (code)=>{
+                    resolveResponse(output, 0 !== code);
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                resolve(`Error: ${errorMessage}`);
+            }
+        }), {
+        name: "command_execute",
+        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the workspace context.",
+        schema: z.object({
+            command: z.string().describe("The command to execute in the terminal")
+        })
+    });
+export { DEFAULT_BLOCKED_COMMANDS, createCommandExecuteTool };