@wingman-ai/gateway 0.1.0

package/dist/agent/tools/git_status.cjs

@@ -0,0 +1,126 @@
+"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__, {
+    createGitStatusTool: ()=>createGitStatusTool
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_node_child_process_namespaceObject = require("node:child_process");
+const createGitStatusTool = (workspace)=>(0, external_langchain_namespaceObject.tool)(async ({ includeDiff = false, includeStaged = false })=>new Promise((resolve)=>{
+            try {
+                const statusProc = (0, external_node_child_process_namespaceObject.spawn)("git", [
+                    "status",
+                    "--porcelain"
+                ], {
+                    cwd: workspace,
+                    shell: false
+                });
+                let output = "";
+                let errorOutput = "";
+                statusProc.stdout.on("data", (data)=>{
+                    output += data.toString();
+                });
+                statusProc.stderr.on("data", (data)=>{
+                    errorOutput += data.toString();
+                });
+                statusProc.on("close", async (code)=>{
+                    if (0 !== code) return void resolve(`Error getting git status: ${errorOutput || "Not a git repository or git not available"}`);
+                    let result = "# Git Status\n\n";
+                    if (output.trim()) {
+                        result += "## Changed Files\n\n";
+                        result += output;
+                        result += "\n";
+                    } else result += "Working directory clean - no uncommitted changes\n";
+                    const branchProc = (0, external_node_child_process_namespaceObject.spawn)("git", [
+                        "branch",
+                        "--show-current"
+                    ], {
+                        cwd: workspace,
+                        shell: false
+                    });
+                    let branchOutput = "";
+                    branchProc.stdout.on("data", (data)=>{
+                        branchOutput += data.toString();
+                    });
+                    branchProc.on("close", async ()=>{
+                        if (branchOutput.trim()) result += `\n## Current Branch\n${branchOutput.trim()}\n`;
+                        if (includeDiff && output.trim()) {
+                            const diffProc = (0, external_node_child_process_namespaceObject.spawn)("git", [
+                                "diff",
+                                "--stat"
+                            ], {
+                                cwd: workspace,
+                                shell: false
+                            });
+                            let diffOutput = "";
+                            diffProc.stdout.on("data", (data)=>{
+                                diffOutput += data.toString();
+                            });
+                            diffProc.on("close", ()=>{
+                                if (diffOutput.trim()) result += `\n## Diff Summary\n${diffOutput}\n`;
+                                resolve(result);
+                            });
+                        } else if (includeStaged && output.trim()) {
+                            const stagedProc = (0, external_node_child_process_namespaceObject.spawn)("git", [
+                                "diff",
+                                "--cached",
+                                "--stat"
+                            ], {
+                                cwd: workspace,
+                                shell: false
+                            });
+                            let stagedOutput = "";
+                            stagedProc.stdout.on("data", (data)=>{
+                                stagedOutput += data.toString();
+                            });
+                            stagedProc.on("close", ()=>{
+                                if (stagedOutput.trim()) result += `\n## Staged Changes\n${stagedOutput}\n`;
+                                resolve(result);
+                            });
+                        } else resolve(result);
+                    });
+                });
+                statusProc.on("error", (err)=>{
+                    resolve(`Failed to execute git: ${err.message}`);
+                });
+            } catch (error) {
+                resolve(`Error getting git status: ${error}`);
+            }
+        }), {
+        name: "git_status",
+        description: "Get current git repository status including uncommitted changes, current branch, and optionally diff statistics. Read-only operation that helps understand the state before making changes.",
+        schema: external_zod_namespaceObject.z.object({
+            includeDiff: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
+            includeStaged: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
+        })
+    });
+exports.createGitStatusTool = __webpack_exports__.createGitStatusTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createGitStatusTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/**
+ * Creates a tool that gets git repository status (read-only)
+ * Helps agents understand the current state without making modifications
+ */
+export declare const createGitStatusTool: (workspace: string) => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    includeDiff: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeStaged: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    includeDiff?: boolean;
+    includeStaged?: boolean;
+}, {
+    includeDiff?: boolean | undefined;
+    includeStaged?: boolean | undefined;
+}, string, "git_status">;

package/dist/agent/tools/git_status.js

@@ -0,0 +1,92 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+const createGitStatusTool = (workspace)=>tool(async ({ includeDiff = false, includeStaged = false })=>new Promise((resolve)=>{
+            try {
+                const statusProc = spawn("git", [
+                    "status",
+                    "--porcelain"
+                ], {
+                    cwd: workspace,
+                    shell: false
+                });
+                let output = "";
+                let errorOutput = "";
+                statusProc.stdout.on("data", (data)=>{
+                    output += data.toString();
+                });
+                statusProc.stderr.on("data", (data)=>{
+                    errorOutput += data.toString();
+                });
+                statusProc.on("close", async (code)=>{
+                    if (0 !== code) return void resolve(`Error getting git status: ${errorOutput || "Not a git repository or git not available"}`);
+                    let result = "# Git Status\n\n";
+                    if (output.trim()) {
+                        result += "## Changed Files\n\n";
+                        result += output;
+                        result += "\n";
+                    } else result += "Working directory clean - no uncommitted changes\n";
+                    const branchProc = spawn("git", [
+                        "branch",
+                        "--show-current"
+                    ], {
+                        cwd: workspace,
+                        shell: false
+                    });
+                    let branchOutput = "";
+                    branchProc.stdout.on("data", (data)=>{
+                        branchOutput += data.toString();
+                    });
+                    branchProc.on("close", async ()=>{
+                        if (branchOutput.trim()) result += `\n## Current Branch\n${branchOutput.trim()}\n`;
+                        if (includeDiff && output.trim()) {
+                            const diffProc = spawn("git", [
+                                "diff",
+                                "--stat"
+                            ], {
+                                cwd: workspace,
+                                shell: false
+                            });
+                            let diffOutput = "";
+                            diffProc.stdout.on("data", (data)=>{
+                                diffOutput += data.toString();
+                            });
+                            diffProc.on("close", ()=>{
+                                if (diffOutput.trim()) result += `\n## Diff Summary\n${diffOutput}\n`;
+                                resolve(result);
+                            });
+                        } else if (includeStaged && output.trim()) {
+                            const stagedProc = spawn("git", [
+                                "diff",
+                                "--cached",
+                                "--stat"
+                            ], {
+                                cwd: workspace,
+                                shell: false
+                            });
+                            let stagedOutput = "";
+                            stagedProc.stdout.on("data", (data)=>{
+                                stagedOutput += data.toString();
+                            });
+                            stagedProc.on("close", ()=>{
+                                if (stagedOutput.trim()) result += `\n## Staged Changes\n${stagedOutput}\n`;
+                                resolve(result);
+                            });
+                        } else resolve(result);
+                    });
+                });
+                statusProc.on("error", (err)=>{
+                    resolve(`Failed to execute git: ${err.message}`);
+                });
+            } catch (error) {
+                resolve(`Error getting git status: ${error}`);
+            }
+        }), {
+        name: "git_status",
+        description: "Get current git repository status including uncommitted changes, current branch, and optionally diff statistics. Read-only operation that helps understand the state before making changes.",
+        schema: z.object({
+            includeDiff: z.boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
+            includeStaged: z.boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
+        })
+    });
+export { createGitStatusTool };

package/dist/agent/tools/internet_search.cjs

@@ -0,0 +1,93 @@
+"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__, {
+    createInternetSearchTool: ()=>createInternetSearchTool,
+    internetSearch: ()=>internetSearch
+});
+const external_langchain_namespaceObject = require("langchain");
+const duckduckgo_search_namespaceObject = require("@langchain/community/tools/duckduckgo_search");
+const openai_namespaceObject = require("@langchain/openai");
+const external_zod_namespaceObject = require("zod");
+function createDuckDuckGoTool(maxResults) {
+    return (0, external_langchain_namespaceObject.tool)(async ({ query, maxResults: queryMaxResults })=>{
+        const search = new duckduckgo_search_namespaceObject.DuckDuckGoSearch({
+            maxResults: queryMaxResults ?? maxResults
+        });
+        return await search._call(query);
+    }, {
+        name: "internet_search",
+        description: "Run a web search using DuckDuckGo",
+        schema: external_zod_namespaceObject.z.object({
+            query: external_zod_namespaceObject.z.string().describe("The search query"),
+            maxResults: external_zod_namespaceObject.z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        })
+    });
+}
+function createPerplexityTool(maxResults) {
+    if (!process.env.OPENROUTER_API_KEY) throw new Error("Perplexity search requires OPENROUTER_API_KEY environment variable. Get your key at https://openrouter.ai/ or switch to DuckDuckGo in wingman.config.json");
+    const model = new openai_namespaceObject.ChatOpenAI({
+        model: "perplexity/sonar",
+        temperature: 1,
+        configuration: {
+            baseURL: "https://openrouter.ai/api/v1",
+            apiKey: process.env.OPENROUTER_API_KEY
+        }
+    });
+    return (0, external_langchain_namespaceObject.tool)(async ({ query, maxResults: queryMaxResults })=>{
+        const limit = queryMaxResults ?? maxResults;
+        const prompt = `Search for: ${query}\n\nProvide up to ${limit} relevant results with citations.`;
+        const response = await model.invoke(prompt);
+        return response.content;
+    }, {
+        name: "internet_search",
+        description: "Run a web search using Perplexity Sonar with built-in citations",
+        schema: external_zod_namespaceObject.z.object({
+            query: external_zod_namespaceObject.z.string().describe("The search query"),
+            maxResults: external_zod_namespaceObject.z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        })
+    });
+}
+function createInternetSearchTool(config) {
+    const { provider, maxResults = 5 } = config;
+    switch(provider){
+        case "duckduckgo":
+            return createDuckDuckGoTool(maxResults);
+        case "perplexity":
+            return createPerplexityTool(maxResults);
+        default:
+            throw new Error(`Unknown search provider: ${provider}`);
+    }
+}
+const internetSearch = createDuckDuckGoTool(5);
+exports.createInternetSearchTool = __webpack_exports__.createInternetSearchTool;
+exports.internetSearch = __webpack_exports__.internetSearch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createInternetSearchTool",
+    "internetSearch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { SearchConfig } from "../../cli/config/schema.js";
+/**
+ * Create an internet search tool based on configuration
+ */
+export declare function createInternetSearchTool(config: SearchConfig): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, {
+    query: string;
+    maxResults?: number;
+}, {
+    query: string;
+    maxResults?: number | undefined;
+}, string | (import("langchain").ContentBlock | import("langchain").ContentBlock.Text)[], "internet_search">;
+export declare const internetSearch: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, {
+    query: string;
+    maxResults?: number;
+}, {
+    query: string;
+    maxResults?: number | undefined;
+}, string, "internet_search">;

package/dist/agent/tools/internet_search.js

@@ -0,0 +1,56 @@
+import { tool } from "langchain";
+import { DuckDuckGoSearch } from "@langchain/community/tools/duckduckgo_search";
+import { ChatOpenAI } from "@langchain/openai";
+import { z } from "zod";
+function createDuckDuckGoTool(maxResults) {
+    return tool(async ({ query, maxResults: queryMaxResults })=>{
+        const search = new DuckDuckGoSearch({
+            maxResults: queryMaxResults ?? maxResults
+        });
+        return await search._call(query);
+    }, {
+        name: "internet_search",
+        description: "Run a web search using DuckDuckGo",
+        schema: z.object({
+            query: z.string().describe("The search query"),
+            maxResults: z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        })
+    });
+}
+function createPerplexityTool(maxResults) {
+    if (!process.env.OPENROUTER_API_KEY) throw new Error("Perplexity search requires OPENROUTER_API_KEY environment variable. Get your key at https://openrouter.ai/ or switch to DuckDuckGo in wingman.config.json");
+    const model = new ChatOpenAI({
+        model: "perplexity/sonar",
+        temperature: 1,
+        configuration: {
+            baseURL: "https://openrouter.ai/api/v1",
+            apiKey: process.env.OPENROUTER_API_KEY
+        }
+    });
+    return tool(async ({ query, maxResults: queryMaxResults })=>{
+        const limit = queryMaxResults ?? maxResults;
+        const prompt = `Search for: ${query}\n\nProvide up to ${limit} relevant results with citations.`;
+        const response = await model.invoke(prompt);
+        return response.content;
+    }, {
+        name: "internet_search",
+        description: "Run a web search using Perplexity Sonar with built-in citations",
+        schema: z.object({
+            query: z.string().describe("The search query"),
+            maxResults: z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        })
+    });
+}
+function createInternetSearchTool(config) {
+    const { provider, maxResults = 5 } = config;
+    switch(provider){
+        case "duckduckgo":
+            return createDuckDuckGoTool(maxResults);
+        case "perplexity":
+            return createPerplexityTool(maxResults);
+        default:
+            throw new Error(`Unknown search provider: ${provider}`);
+    }
+}
+const internetSearch = createDuckDuckGoTool(5);
+export { createInternetSearchTool, internetSearch };

package/dist/agent/tools/think.cjs

@@ -0,0 +1,53 @@
+"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__, {
+    createThinkingTool: ()=>createThinkingTool,
+    readFileSchema: ()=>readFileSchema
+});
+const tools_namespaceObject = require("@langchain/core/tools");
+const external_zod_namespaceObject = require("zod");
+const readFileSchema = external_zod_namespaceObject.z.object({
+    thought: external_zod_namespaceObject.z.object({
+        type: external_zod_namespaceObject.z.string(),
+        description: external_zod_namespaceObject.z.string().describe("Your thoughts in plain text")
+    })
+});
+const createThinkingTool = ()=>(0, tools_namespaceObject.tool)(async (input)=>JSON.stringify({
+            input
+        }), {
+        name: "think",
+        description: "Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed. For example, if you explore the repo and discover the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective. Alternatively, if you receive some test results, call this tool to brainstorm ways to fix the failing tests.",
+        schema: readFileSchema
+    });
+exports.createThinkingTool = __webpack_exports__.createThinkingTool;
+exports.readFileSchema = __webpack_exports__.readFileSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createThinkingTool",
+    "readFileSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const readFileSchema: z.ZodObject<{
+    thought: z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Creates a tool that reads file contents
+ */
+export declare const createThinkingTool: () => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    thought: z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, {
+    thought: {
+        type: string;
+        description: string;
+    };
+}, {
+    thought: {
+        type: string;
+        description: string;
+    };
+}, string, "think">;

package/dist/agent/tools/think.js

@@ -0,0 +1,16 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+const readFileSchema = z.object({
+    thought: z.object({
+        type: z.string(),
+        description: z.string().describe("Your thoughts in plain text")
+    })
+});
+const createThinkingTool = ()=>tool(async (input)=>JSON.stringify({
+            input
+        }), {
+        name: "think",
+        description: "Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed. For example, if you explore the repo and discover the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective. Alternatively, if you receive some test results, call this tool to brainstorm ways to fix the failing tests.",
+        schema: readFileSchema
+    });
+export { createThinkingTool, readFileSchema };