@morphllm/morphsdk 0.2.69 → 0.2.70

package/dist/tools/warp_grep/gemini.d.ts

@@ -1,7 +1,113 @@
-import '@google/generative-ai';
+import { FunctionDeclaration } from '@google/generative-ai';
 export { formatResult } from './client.js';
 export { getSystemPrompt } from './agent/prompt.js';
-import '../../types-CnvVDM63.js';
-export { G as GeminiWarpGrepTool, a as createMorphWarpGrepTool, c as createWarpGrepTool, w as default, e as execute, w as warpGrepFunctionDeclaration } from '../../gemini-BIFBiIjY.js';
+import { d as WarpGrepToolConfig, b as WarpGrepResult } from '../../types-CnvVDM63.js';
 import './providers/types.js';
 import '../utils/resilience.js';
+
+/**
+ * Google Gemini SDK adapter for morph-warp-grep tool
+ *
+ * Requires @google/generative-ai as a peer dependency.
+ * Install with: npm install @google/generative-ai
+ */
+
+/**
+ * Gemini-native warp grep function declaration
+ *
+ * @example
+ * ```typescript
+ * import { GoogleGenerativeAI } from '@google/generative-ai';
+ * import { warpGrepFunctionDeclaration, execute } from '@morphllm/morphsdk/tools/warp-grep/gemini';
+ *
+ * const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
+ * const model = genAI.getGenerativeModel({
+ *   model: 'gemini-2.0-flash',
+ *   tools: [{ functionDeclarations: [warpGrepFunctionDeclaration] }]
+ * });
+ *
+ * const chat = model.startChat();
+ * const result = await chat.sendMessage('Find authentication middleware');
+ *
+ * // Handle function call
+ * const call = result.response.functionCalls()?.[0];
+ * if (call) {
+ *   const searchResult = await execute(call.args, { repoRoot: '.' });
+ *   console.log(searchResult);
+ * }
+ * ```
+ */
+declare const warpGrepFunctionDeclaration: FunctionDeclaration;
+/**
+ * Execute warp grep search
+ *
+ * @param input - Tool input with query
+ * @param config - Configuration with repoRoot and optional provider
+ * @returns Search results
+ */
+declare function execute(input: {
+    query: string;
+} | string, config: WarpGrepToolConfig): Promise<WarpGrepResult>;
+
+/**
+ * Gemini tool with execute method attached
+ */
+interface GeminiWarpGrepTool extends FunctionDeclaration {
+    execute: (input: unknown) => Promise<WarpGrepResult>;
+    formatResult: (result: WarpGrepResult) => string;
+    getSystemPrompt: () => string;
+}
+/**
+ * Create a custom warp grep tool with configuration and methods
+ *
+ * @param config - Configuration options
+ * @returns Function declaration with execute and formatResult methods
+ *
+ * @example Local usage
+ * ```typescript
+ * import { GoogleGenerativeAI } from '@google/generative-ai';
+ * import { createMorphWarpGrepTool } from '@morphllm/morphsdk/tools/warp-grep/gemini';
+ *
+ * const tool = createMorphWarpGrepTool({ repoRoot: '.' });
+ *
+ * const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
+ * const model = genAI.getGenerativeModel({
+ *   model: 'gemini-2.0-flash',
+ *   tools: [{ functionDeclarations: [tool] }]
+ * });
+ *
+ * const chat = model.startChat();
+ * const result = await chat.sendMessage('Find authentication middleware');
+ *
+ * // Handle function call
+ * const call = result.response.functionCalls()?.[0];
+ * if (call && call.name === tool.name) {
+ *   const searchResult = await tool.execute(call.args);
+ *   console.log(tool.formatResult(searchResult));
+ *
+ *   // Send result back to model
+ *   await chat.sendMessage([{
+ *     functionResponse: {
+ *       name: call.name,
+ *       response: { result: tool.formatResult(searchResult) }
+ *     }
+ *   }]);
+ * }
+ * ```
+ *
+ * @example Remote sandbox (E2B, Modal, etc.)
+ * ```typescript
+ * const tool = createMorphWarpGrepTool({
+ *   repoRoot: '/home/repo',
+ *   remoteCommands: {
+ *     grep: async (pattern, path) => (await sandbox.run(`rg '${pattern}' '${path}'`)).stdout,
+ *     read: async (path, start, end) => (await sandbox.run(`sed -n '${start},${end}p' '${path}'`)).stdout,
+ *     listDir: async (path, maxDepth) => (await sandbox.run(`find '${path}' -maxdepth ${maxDepth}`)).stdout,
+ *   },
+ * });
+ * ```
+ */
+declare function createWarpGrepTool(config: WarpGrepToolConfig): GeminiWarpGrepTool;
+declare const createMorphWarpGrepTool: typeof createWarpGrepTool;
+
+export { type GeminiWarpGrepTool, createMorphWarpGrepTool, createWarpGrepTool, warpGrepFunctionDeclaration as default, execute, warpGrepFunctionDeclaration };

package/dist/tools/warp_grep/gemini.js

@@ -1,12 +1,9 @@
 import {
-  createMorphWarpGrepTool,
-  createWarpGrepTool,
-  execute,
-  gemini_default,
-  warpGrepFunctionDeclaration
-} from "../../chunk-2LSVUHIE.js";
-import "../../chunk-KW7OEGZK.js";
+  WARP_GREP_DESCRIPTION,
+  WARP_GREP_TOOL_NAME
+} from "../../chunk-KW7OEGZK.js";
 import {
+  executeToolCall,
   formatResult
 } from "../../chunk-E4434A4Y.js";
 import "../../chunk-SUBBMTMY.js";
@@ -24,6 +21,46 @@ import "../../chunk-TPP2UGQP.js";
 import "../../chunk-XT5ZO6ES.js";
 import "../../chunk-4VWJFZVS.js";
 import "../../chunk-PZ5AY32C.js";
+
+// tools/warp_grep/gemini.ts
+var TOOL_PARAMETERS = {
+  type: "OBJECT",
+  properties: {
+    query: {
+      type: "STRING",
+      description: "Free-form repository question"
+    }
+  },
+  required: ["query"]
+};
+var warpGrepFunctionDeclaration = {
+  name: WARP_GREP_TOOL_NAME,
+  description: WARP_GREP_DESCRIPTION,
+  parameters: TOOL_PARAMETERS
+};
+async function execute(input, config) {
+  return executeToolCall(input, config);
+}
+function createWarpGrepTool(config) {
+  const declaration = {
+    name: config.name ?? WARP_GREP_TOOL_NAME,
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    parameters: TOOL_PARAMETERS
+  };
+  return Object.assign(declaration, {
+    execute: async (input) => {
+      return executeToolCall(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt();
+    }
+  });
+}
+var createMorphWarpGrepTool = createWarpGrepTool;
+var gemini_default = warpGrepFunctionDeclaration;
 export {
   createMorphWarpGrepTool,
   createWarpGrepTool,

package/dist/tools/warp_grep/gemini.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../../tools/warp_grep/gemini.ts"],"sourcesContent":["/**\n * Google Gemini SDK adapter for morph-warp-grep tool\n * \n * Requires @google/generative-ai as a peer dependency.\n * Install with: npm install @google/generative-ai\n */\n\nimport type { FunctionDeclaration, FunctionDeclarationSchema } from '@google/generative-ai';\nimport { executeToolCall, formatResult } from './client.js';\nimport { WARP_GREP_DESCRIPTION, WARP_GREP_TOOL_NAME, getSystemPrompt } from './prompts.js';\nimport type { WarpGrepToolConfig, WarpGrepResult } from './types.js';\n\n// Use plain object to avoid runtime import of SchemaType enum\nconst TOOL_PARAMETERS = {\n  type: 'OBJECT',\n  properties: {\n    query: { \n      type: 'STRING', \n      description: 'Free-form repository question' \n    },\n  },\n  required: ['query'],\n} as unknown as FunctionDeclarationSchema;\n\n/**\n * Gemini-native warp grep function declaration\n * \n * @example\n * ```typescript\n * import { GoogleGenerativeAI } from '@google/generative-ai';\n * import { warpGrepFunctionDeclaration, execute } from '@morphllm/morphsdk/tools/warp-grep/gemini';\n * \n * const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);\n * const model = genAI.getGenerativeModel({\n *   model: 'gemini-2.0-flash',\n *   tools: [{ functionDeclarations: [warpGrepFunctionDeclaration] }]\n * });\n * \n * const chat = model.startChat();\n * const result = await chat.sendMessage('Find authentication middleware');\n * \n * // Handle function call\n * const call = result.response.functionCalls()?.[0];\n * if (call) {\n *   const searchResult = await execute(call.args, { repoRoot: '.' });\n *   console.log(searchResult);\n * }\n * ```\n */\nexport const warpGrepFunctionDeclaration: FunctionDeclaration = {\n  name: WARP_GREP_TOOL_NAME,\n  description: WARP_GREP_DESCRIPTION,\n  parameters: TOOL_PARAMETERS,\n};\n\n/**\n * Execute warp grep search\n * \n * @param input - Tool input with query\n * @param config - Configuration with repoRoot and optional provider\n * @returns Search results\n */\nexport async function execute(\n  input: { query: string } | string,\n  config: WarpGrepToolConfig\n): Promise<WarpGrepResult> {\n  return executeToolCall(input, config);\n}\n\nexport { formatResult, getSystemPrompt };\n\n/**\n * Gemini tool with execute method attached\n */\nexport interface GeminiWarpGrepTool extends FunctionDeclaration {\n  execute: (input: unknown) => Promise<WarpGrepResult>;\n  formatResult: (result: WarpGrepResult) => string;\n  getSystemPrompt: () => string;\n}\n\n/**\n * Create a custom warp grep tool with configuration and methods\n * \n * @param config - Configuration options\n * @returns Function declaration with execute and formatResult methods\n * \n * @example Local usage\n * ```typescript\n * import { GoogleGenerativeAI } from '@google/generative-ai';\n * import { createMorphWarpGrepTool } from '@morphllm/morphsdk/tools/warp-grep/gemini';\n * \n * const tool = createMorphWarpGrepTool({ repoRoot: '.' });\n * \n * const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);\n * const model = genAI.getGenerativeModel({\n *   model: 'gemini-2.0-flash',\n *   tools: [{ functionDeclarations: [tool] }]\n * });\n * \n * const chat = model.startChat();\n * const result = await chat.sendMessage('Find authentication middleware');\n * \n * // Handle function call\n * const call = result.response.functionCalls()?.[0];\n * if (call && call.name === tool.name) {\n *   const searchResult = await tool.execute(call.args);\n *   console.log(tool.formatResult(searchResult));\n *   \n *   // Send result back to model\n *   await chat.sendMessage([{\n *     functionResponse: {\n *       name: call.name,\n *       response: { result: tool.formatResult(searchResult) }\n *     }\n *   }]);\n * }\n * ```\n * \n * @example Remote sandbox (E2B, Modal, etc.)\n * ```typescript\n * const tool = createMorphWarpGrepTool({\n *   repoRoot: '/home/repo',\n *   remoteCommands: {\n *     grep: async (pattern, path) => (await sandbox.run(`rg '${pattern}' '${path}'`)).stdout,\n *     read: async (path, start, end) => (await sandbox.run(`sed -n '${start},${end}p' '${path}'`)).stdout,\n *     listDir: async (path, maxDepth) => (await sandbox.run(`find '${path}' -maxdepth ${maxDepth}`)).stdout,\n *   },\n * });\n * ```\n */\nexport function createWarpGrepTool(config: WarpGrepToolConfig): GeminiWarpGrepTool {\n  const declaration: FunctionDeclaration = {\n    name: config.name ?? WARP_GREP_TOOL_NAME,\n    description: config.description ?? WARP_GREP_DESCRIPTION,\n    parameters: TOOL_PARAMETERS,\n  };\n\n  return Object.assign(declaration, {\n    execute: async (input: unknown): Promise<WarpGrepResult> => {\n      return executeToolCall(input as { query: string } | string, config);\n    },\n    formatResult: (result: WarpGrepResult): string => {\n      return formatResult(result);\n    },\n    getSystemPrompt: (): string => {\n      return getSystemPrompt();\n    },\n  });\n}\n\n// Legacy alias for backwards compatibility\nexport const createMorphWarpGrepTool = createWarpGrepTool;\n\nexport default warpGrepFunctionDeclaration;\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAaA,IAAM,kBAAkB;AAAA,EACtB,MAAM;AAAA,EACN,YAAY;AAAA,IACV,OAAO;AAAA,MACL,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,UAAU,CAAC,OAAO;AACpB;AA2BO,IAAM,8BAAmD;AAAA,EAC9D,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AACd;AASA,eAAsB,QACpB,OACA,QACyB;AACzB,SAAO,gBAAgB,OAAO,MAAM;AACtC;AA+DO,SAAS,mBAAmB,QAAgD;AACjF,QAAM,cAAmC;AAAA,IACvC,MAAM,OAAO,QAAQ;AAAA,IACrB,aAAa,OAAO,eAAe;AAAA,IACnC,YAAY;AAAA,EACd;AAEA,SAAO,OAAO,OAAO,aAAa;AAAA,IAChC,SAAS,OAAO,UAA4C;AAC1D,aAAO,gBAAgB,OAAqC,MAAM;AAAA,IACpE;AAAA,IACA,cAAc,CAAC,WAAmC;AAChD,aAAO,aAAa,MAAM;AAAA,IAC5B;AAAA,IACA,iBAAiB,MAAc;AAC7B,aAAO,gBAAgB;AAAA,IACzB;AAAA,EACF,CAAC;AACH;AAGO,IAAM,0BAA0B;AAEvC,IAAO,iBAAQ;","names":[]}

package/dist/tools/warp_grep/index.cjs

@@ -36,22 +36,20 @@ __export(warp_grep_exports, {
   WARP_GREP_SYSTEM_PROMPT: () => SYSTEM_PROMPT,
   WARP_GREP_TOOL_NAME: () => WARP_GREP_TOOL_NAME,
   WarpGrepClient: () => WarpGrepClient,
-  anthropic: () => anthropic_exports,
   executeToolCall: () => executeToolCall,
   executeWarpGrep: () => executeWarpGrep,
   formatResult: () => formatResult,
-  gemini: () => gemini_exports,
   getSystemPrompt: () => getSystemPrompt,
   normalizeFinishFiles: () => normalizeFinishFiles,
-  openai: () => openai_exports,
   readFinishFiles: () => readFinishFiles,
   runWarpGrep: () => runWarpGrep,
   toolGrep: () => toolGrep,
   toolListDirectory: () => toolListDirectory,
   toolRead: () => toolRead,
-  vercel: () => vercel_exports
+  warpGrepInputSchema: () => warpGrepInputSchema
 });
 module.exports = __toCommonJS(warp_grep_exports);
+var import_zod = require("zod");
 
 // tools/warp_grep/agent/config.ts
 var AGENT_CONFIG = {
@@ -1763,186 +1761,10 @@ function formatResult(result) {
 var WARP_GREP_TOOL_NAME = "warpgrep_codebase_search";
 var WARP_GREP_DESCRIPTION = 'IMPORTANT: If you need to explore the codebase to gather context, and the task does not involve a single file or function which is provided by name, you should ALWAYS use the warpgrep codebase search tool first instead of running search commands. When the task requires exploration beyond a single known file, invoke warpgrep first with a natural-language query describing the target functionality, bug, or architectural concern. Warp Grep is a fast and accurate tool that can search for all relevant context in a codebase. Keep queries action-oriented (e.g., "Find where billing invoices are generated and emailed"), and after reviewing the summarized results, you may verify important findings with other search tools or direct file reads to ensure completeness. Warp Grep can be used for query types like: find function responsible for <small feature>; find code that does <description>; find code path for <big feature>; Where does <minimal error message> come from?; or any query of that type. When a task requires exploration beyond a single known file, ALWAYS default to warpgrep codebase search before other search mechanisms.';
 
-// tools/warp_grep/anthropic.ts
-var anthropic_exports = {};
-__export(anthropic_exports, {
-  createWarpGrepTool: () => createWarpGrepTool,
-  execute: () => execute,
-  formatResult: () => formatResult,
-  getSystemPrompt: () => getSystemPrompt,
-  warpGrepTool: () => warpGrepTool
-});
-var INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    query: { type: "string", description: "Free-form repository question" }
-  },
-  required: ["query"]
-};
-var warpGrepTool = {
-  name: WARP_GREP_TOOL_NAME,
-  description: WARP_GREP_DESCRIPTION,
-  input_schema: INPUT_SCHEMA
-};
-async function execute(input, config) {
-  return executeToolCall(input, config);
-}
-function createWarpGrepTool(config) {
-  const tool2 = {
-    name: config.name ?? WARP_GREP_TOOL_NAME,
-    description: config.description ?? WARP_GREP_DESCRIPTION,
-    input_schema: INPUT_SCHEMA
-  };
-  return Object.assign(tool2, {
-    execute: async (input) => {
-      return executeToolCall(input, config);
-    },
-    formatResult: (result) => {
-      return formatResult(result);
-    },
-    getSystemPrompt: () => {
-      return getSystemPrompt();
-    }
-  });
-}
-
-// tools/warp_grep/openai.ts
-var openai_exports = {};
-__export(openai_exports, {
-  createWarpGrepTool: () => createWarpGrepTool2,
-  default: () => openai_default,
-  execute: () => execute2,
-  formatResult: () => formatResult,
-  getSystemPrompt: () => getSystemPrompt,
-  warpGrepTool: () => warpGrepTool2
-});
-var TOOL_PARAMETERS = {
-  type: "object",
-  properties: {
-    query: { type: "string", description: "Free-form repository question" }
-  },
-  required: ["query"]
-};
-var warpGrepTool2 = {
-  type: "function",
-  function: {
-    name: WARP_GREP_TOOL_NAME,
-    description: WARP_GREP_DESCRIPTION,
-    parameters: TOOL_PARAMETERS
-  }
-};
-async function execute2(input, config) {
-  return executeToolCall(input, config);
-}
-function createWarpGrepTool2(config) {
-  const tool2 = {
-    type: "function",
-    function: {
-      name: config.name ?? WARP_GREP_TOOL_NAME,
-      description: config.description ?? WARP_GREP_DESCRIPTION,
-      parameters: TOOL_PARAMETERS
-    }
-  };
-  return Object.assign(tool2, {
-    execute: async (input) => {
-      return executeToolCall(input, config);
-    },
-    formatResult: (result) => {
-      return formatResult(result);
-    },
-    getSystemPrompt: () => {
-      return getSystemPrompt();
-    }
-  });
-}
-var openai_default = warpGrepTool2;
-
-// tools/warp_grep/vercel.ts
-var vercel_exports = {};
-__export(vercel_exports, {
-  createWarpGrepTool: () => createWarpGrepTool3,
-  default: () => vercel_default,
-  execute: () => execute3,
-  formatResult: () => formatResult,
-  getSystemPrompt: () => getSystemPrompt
-});
-var import_ai = require("ai");
-var import_zod = require("zod");
-async function execute3(input, config) {
-  return executeToolCall(input, config);
-}
-function createWarpGrepTool3(config) {
-  const schema = import_zod.z.object({
-    query: import_zod.z.string().describe("Free-form repository question")
-  });
-  return (0, import_ai.tool)({
-    description: config.description ?? WARP_GREP_DESCRIPTION,
-    inputSchema: schema,
-    execute: async (params) => {
-      const result = await executeToolCall(params, config);
-      if (!result.success) {
-        throw new Error(`Failed to search codebase: ${result.error}`);
-      }
-      return {
-        success: true,
-        contexts: result.contexts,
-        summary: result.summary
-      };
-    }
-  });
-}
-var vercel_default = createWarpGrepTool3;
-
-// tools/warp_grep/gemini.ts
-var gemini_exports = {};
-__export(gemini_exports, {
-  createMorphWarpGrepTool: () => createMorphWarpGrepTool,
-  createWarpGrepTool: () => createWarpGrepTool4,
-  default: () => gemini_default,
-  execute: () => execute4,
-  formatResult: () => formatResult,
-  getSystemPrompt: () => getSystemPrompt,
-  warpGrepFunctionDeclaration: () => warpGrepFunctionDeclaration
+// tools/warp_grep/index.ts
+var warpGrepInputSchema = import_zod.z.object({
+  query: import_zod.z.string().describe("Free-form repository question")
 });
-var import_generative_ai = require("@google/generative-ai");
-var TOOL_PARAMETERS2 = {
-  type: import_generative_ai.SchemaType.OBJECT,
-  properties: {
-    query: {
-      type: import_generative_ai.SchemaType.STRING,
-      description: "Free-form repository question"
-    }
-  },
-  required: ["query"]
-};
-var warpGrepFunctionDeclaration = {
-  name: WARP_GREP_TOOL_NAME,
-  description: WARP_GREP_DESCRIPTION,
-  parameters: TOOL_PARAMETERS2
-};
-async function execute4(input, config) {
-  return executeToolCall(input, config);
-}
-function createWarpGrepTool4(config) {
-  const declaration = {
-    name: config.name ?? WARP_GREP_TOOL_NAME,
-    description: config.description ?? WARP_GREP_DESCRIPTION,
-    parameters: TOOL_PARAMETERS2
-  };
-  return Object.assign(declaration, {
-    execute: async (input) => {
-      return executeToolCall(input, config);
-    },
-    formatResult: (result) => {
-      return formatResult(result);
-    },
-    getSystemPrompt: () => {
-      return getSystemPrompt();
-    }
-  });
-}
-var createMorphWarpGrepTool = createWarpGrepTool4;
-var gemini_default = warpGrepFunctionDeclaration;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LocalRipgrepProvider,
@@ -1951,19 +1773,16 @@ var gemini_default = warpGrepFunctionDeclaration;
   WARP_GREP_SYSTEM_PROMPT,
   WARP_GREP_TOOL_NAME,
   WarpGrepClient,
-  anthropic,
   executeToolCall,
   executeWarpGrep,
   formatResult,
-  gemini,
   getSystemPrompt,
   normalizeFinishFiles,
-  openai,
   readFinishFiles,
   runWarpGrep,
   toolGrep,
   toolListDirectory,
   toolRead,
-  vercel
+  warpGrepInputSchema
 });
 //# sourceMappingURL=index.cjs.map