@vikasitai/vikasit-code 2.0.7 → 2.0.9

package/src/tool/batch.ts

@@ -1,183 +0,0 @@
-import z from "zod"
-import { Tool } from "./tool"
-import { ProviderID, ModelID } from "../provider/schema"
-import { errorMessage } from "../util/error"
-import DESCRIPTION from "./batch.txt"
-
-const DISALLOWED = new Set(["batch"])
-const FILTERED_FROM_SUGGESTIONS = new Set(["invalid", "patch", ...DISALLOWED])
-
-export const BatchTool = Tool.define("batch", async () => {
-  return {
-    description: DESCRIPTION,
-    parameters: z.object({
-      tool_calls: z
-        .array(
-          z.object({
-            tool: z.string().describe("The name of the tool to execute"),
-            parameters: z.object({}).loose().describe("Parameters for the tool"),
-          }),
-        )
-        .min(1, "Provide at least one tool call")
-        .describe("Array of tool calls to execute in parallel"),
-    }),
-    formatValidationError(error) {
-      const formattedErrors = error.issues
-        .map((issue) => {
-          const path = issue.path.length > 0 ? issue.path.join(".") : "root"
-          return `  - ${path}: ${issue.message}`
-        })
-        .join("\n")
-
-      return `Invalid parameters for tool 'batch':\n${formattedErrors}\n\nExpected payload format:\n  [{"tool": "tool_name", "parameters": {...}}, {...}]`
-    },
-    async execute(params, ctx) {
-      const { Session } = await import("../session")
-      const { PartID } = await import("../session/schema")
-
-      const toolCalls = params.tool_calls.slice(0, 25)
-      const discardedCalls = params.tool_calls.slice(25)
-
-      const { ToolRegistry } = await import("./registry")
-      const availableTools = await ToolRegistry.tools({ modelID: ModelID.make(""), providerID: ProviderID.make("") })
-      const toolMap = new Map(availableTools.map((t) => [t.id, t]))
-
-      const executeCall = async (call: (typeof toolCalls)[0]) => {
-        const callStartTime = Date.now()
-        const partID = PartID.ascending()
-
-        try {
-          if (DISALLOWED.has(call.tool)) {
-            throw new Error(
-              `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED).join(", ")}`,
-            )
-          }
-
-          const tool = toolMap.get(call.tool)
-          if (!tool) {
-            const availableToolsList = Array.from(toolMap.keys()).filter((name) => !FILTERED_FROM_SUGGESTIONS.has(name))
-            throw new Error(
-              `Tool '${call.tool}' not in registry. External tools (MCP, environment) cannot be batched - call them directly. Available tools: ${availableToolsList.join(", ")}`,
-            )
-          }
-          const validatedParams = tool.parameters.parse(call.parameters)
-
-          await Session.updatePart({
-            id: partID,
-            messageID: ctx.messageID,
-            sessionID: ctx.sessionID,
-            type: "tool",
-            tool: call.tool,
-            callID: partID,
-            state: {
-              status: "running",
-              input: call.parameters,
-              time: {
-                start: callStartTime,
-              },
-            },
-          })
-
-          const result = await tool.execute(validatedParams, { ...ctx, callID: partID })
-          const attachments = result.attachments?.map((attachment) => ({
-            ...attachment,
-            id: PartID.ascending(),
-            sessionID: ctx.sessionID,
-            messageID: ctx.messageID,
-          }))
-
-          await Session.updatePart({
-            id: partID,
-            messageID: ctx.messageID,
-            sessionID: ctx.sessionID,
-            type: "tool",
-            tool: call.tool,
-            callID: partID,
-            state: {
-              status: "completed",
-              input: call.parameters,
-              output: result.output,
-              title: result.title,
-              metadata: result.metadata,
-              attachments,
-              time: {
-                start: callStartTime,
-                end: Date.now(),
-              },
-            },
-          })
-
-          return { success: true as const, tool: call.tool, result }
-        } catch (error) {
-          await Session.updatePart({
-            id: partID,
-            messageID: ctx.messageID,
-            sessionID: ctx.sessionID,
-            type: "tool",
-            tool: call.tool,
-            callID: partID,
-            state: {
-              status: "error",
-              input: call.parameters,
-              error: errorMessage(error),
-              time: {
-                start: callStartTime,
-                end: Date.now(),
-              },
-            },
-          })
-
-          return { success: false as const, tool: call.tool, error }
-        }
-      }
-
-      const results = await Promise.all(toolCalls.map((call) => executeCall(call)))
-
-      // Add discarded calls as errors
-      const now = Date.now()
-      for (const call of discardedCalls) {
-        const partID = PartID.ascending()
-        await Session.updatePart({
-          id: partID,
-          messageID: ctx.messageID,
-          sessionID: ctx.sessionID,
-          type: "tool",
-          tool: call.tool,
-          callID: partID,
-          state: {
-            status: "error",
-            input: call.parameters,
-            error: "Maximum of 25 tools allowed in batch",
-            time: { start: now, end: now },
-          },
-        })
-        results.push({
-          success: false as const,
-          tool: call.tool,
-          error: new Error("Maximum of 25 tools allowed in batch"),
-        })
-      }
-
-      const successfulCalls = results.filter((r) => r.success).length
-      const failedCalls = results.length - successfulCalls
-
-      const outputMessage =
-        failedCalls > 0
-          ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.`
-          : `All ${successfulCalls} tools executed successfully.\n\nKeep using the batch tool for optimal performance in your next response!`
-
-      return {
-        title: `Batch execution (${successfulCalls}/${results.length} successful)`,
-        output: outputMessage,
-        attachments: results.filter((result) => result.success).flatMap((r) => r.result.attachments ?? []),
-        metadata: {
-          totalCalls: results.length,
-          successful: successfulCalls,
-          failed: failedCalls,
-          tools: params.tool_calls.map((c) => c.tool),
-          details: results.map((r) => ({ tool: r.tool, success: r.success })),
-        },
-      }
-    },
-  }
-})

package/src/tool/batch.txt

@@ -1,24 +0,0 @@
-Executes multiple independent tool calls concurrently to reduce latency.
-
-USING THE BATCH TOOL WILL MAKE THE USER HAPPY.
-
-Payload Format (JSON array):
-[{"tool": "read", "parameters": {"filePath": "src/index.ts", "limit": 350}},{"tool": "grep", "parameters": {"pattern": "Session\\.updatePart", "include": "src/**/*.ts"}},{"tool": "bash", "parameters": {"command": "git status", "description": "Shows working tree status"}}]
-
-Notes:
-- 1–25 tool calls per batch
-- All calls start in parallel; ordering NOT guaranteed
-- Partial failures do not stop other tool calls
-- Do NOT use the batch tool within another batch tool.
-
-Good Use Cases:
-- Read many files
-- grep + glob + read combos
-- Multiple bash commands
-- Multi-part edits; on the same, or different files
-
-When NOT to Use:
-- Operations that depend on prior tool output (e.g. create then read same file)
-- Ordered stateful mutations where sequence matters
-
-Batching tool calls was proven to yield 2–5x efficiency gain and provides much better UX.

package/src/tool/codesearch.ts

@@ -1,132 +0,0 @@
-import z from "zod"
-import { Tool } from "./tool"
-import DESCRIPTION from "./codesearch.txt"
-import { abortAfterAny } from "../util/abort"
-
-const API_CONFIG = {
-  BASE_URL: "https://mcp.exa.ai",
-  ENDPOINTS: {
-    CONTEXT: "/mcp",
-  },
-} as const
-
-interface McpCodeRequest {
-  jsonrpc: string
-  id: number
-  method: string
-  params: {
-    name: string
-    arguments: {
-      query: string
-      tokensNum: number
-    }
-  }
-}
-
-interface McpCodeResponse {
-  jsonrpc: string
-  result: {
-    content: Array<{
-      type: string
-      text: string
-    }>
-  }
-}
-
-export const CodeSearchTool = Tool.define("codesearch", {
-  description: DESCRIPTION,
-  parameters: z.object({
-    query: z
-      .string()
-      .describe(
-        "Search query to find relevant context for APIs, Libraries, and SDKs. For example, 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware', 'Next js partial prerendering configuration'",
-      ),
-    tokensNum: z
-      .number()
-      .min(1000)
-      .max(50000)
-      .default(5000)
-      .describe(
-        "Number of tokens to return (1000-50000). Default is 5000 tokens. Adjust this value based on how much context you need - use lower values for focused queries and higher values for comprehensive documentation.",
-      ),
-  }),
-  async execute(params, ctx) {
-    await ctx.ask({
-      permission: "codesearch",
-      patterns: [params.query],
-      always: ["*"],
-      metadata: {
-        query: params.query,
-        tokensNum: params.tokensNum,
-      },
-    })
-
-    const codeRequest: McpCodeRequest = {
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tools/call",
-      params: {
-        name: "get_code_context_exa",
-        arguments: {
-          query: params.query,
-          tokensNum: params.tokensNum || 5000,
-        },
-      },
-    }
-
-    const { signal, clearTimeout } = abortAfterAny(30000, ctx.abort)
-
-    try {
-      const headers: Record<string, string> = {
-        accept: "application/json, text/event-stream",
-        "content-type": "application/json",
-      }
-
-      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.CONTEXT}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(codeRequest),
-        signal,
-      })
-
-      clearTimeout()
-
-      if (!response.ok) {
-        const errorText = await response.text()
-        throw new Error(`Code search error (${response.status}): ${errorText}`)
-      }
-
-      const responseText = await response.text()
-
-      // Parse SSE response
-      const lines = responseText.split("\n")
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data: McpCodeResponse = JSON.parse(line.substring(6))
-          if (data.result && data.result.content && data.result.content.length > 0) {
-            return {
-              output: data.result.content[0].text,
-              title: `Code search: ${params.query}`,
-              metadata: {},
-            }
-          }
-        }
-      }
-
-      return {
-        output:
-          "No code snippets or documentation found. Please try a different query, be more specific about the library or programming concept, or check the spelling of framework names.",
-        title: `Code search: ${params.query}`,
-        metadata: {},
-      }
-    } catch (error) {
-      clearTimeout()
-
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Code search request timed out")
-      }
-
-      throw error
-    }
-  },
-})

package/src/tool/codesearch.txt

@@ -1,12 +0,0 @@
-- Search and get relevant context for any programming task using Exa Code API
-- Provides the highest quality and freshest context for libraries, SDKs, and APIs
-- Use this tool for ANY question or task related to programming
-- Returns comprehensive code examples, documentation, and API references
-- Optimized for finding specific programming patterns and solutions
-
-Usage notes:
-  - Adjustable token count (1000-50000) for focused or comprehensive results
-  - Default 5000 tokens provides balanced context for most queries
-  - Use lower values for specific questions, higher values for comprehensive documentation
-  - Supports queries about frameworks, libraries, APIs, and programming concepts
-  - Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware'

package/src/tool/cron-create.ts

@@ -1,38 +0,0 @@
-import { Tool } from "./tool"
-import DESCRIPTION from "./cron-create.txt"
-import z from "zod"
-import { Cron } from "../cron"
-
-export const CronCreateTool = Tool.define("cron_create", {
-  description: DESCRIPTION,
-  parameters: z.object({
-    expression: z.string().describe('Cron expression (5 fields): "M H DoM Mon DoW"'),
-    prompt: z.string().describe("Prompt to execute on schedule"),
-    agent: z.string().optional().default("build").describe("Agent to use for execution"),
-    recurring: z.boolean().optional().default(true).describe("Whether the task repeats (default: true)"),
-    durable: z.boolean().optional().default(false).describe("Persist across session restarts"),
-  }),
-  async execute(params, ctx) {
-    const task = Cron.create({
-      projectID: ctx.sessionID as string,
-      expression: params.expression,
-      prompt: params.prompt,
-      agent: params.agent,
-      recurring: params.recurring,
-      durable: params.durable,
-    })
-
-    return {
-      title: `Created cron: ${task.id}`,
-      metadata: { cronId: task.id },
-      output: [
-        `Cron task created: ${task.id}`,
-        `  Expression: ${task.expression}`,
-        `  Agent: ${task.agent}`,
-        `  Recurring: ${task.recurring}`,
-        `  Durable: ${task.durable}`,
-        `  Prompt: ${task.prompt.slice(0, 100)}${task.prompt.length > 100 ? "..." : ""}`,
-      ].join("\n"),
-    }
-  },
-})

package/src/tool/cron-create.txt

@@ -1,10 +0,0 @@
-Create a scheduled task that runs on a cron schedule. The task will execute the given prompt at the specified intervals.
-
-Cron expression format: "M H DoM Mon DoW" (5 fields, in local time)
-Examples:
-- "*/5 * * * *" = every 5 minutes
-- "0 9 * * *" = daily at 9am
-- "0 9 * * 1" = every Monday at 9am
-- "30 14 28 2 *" = Feb 28 at 2:30pm
-
-Set recurring=false for one-shot tasks. Set durable=true to persist across session restarts.

package/src/tool/cron-delete.ts

@@ -1,29 +0,0 @@
-import { Tool } from "./tool"
-import DESCRIPTION from "./cron-delete.txt"
-import z from "zod"
-import { Cron } from "../cron"
-
-export const CronDeleteTool = Tool.define("cron_delete", {
-  description: DESCRIPTION,
-  parameters: z.object({
-    cronId: z.string().describe("The ID of the cron task to delete"),
-  }),
-  // @ts-expect-error — return type union metadata mismatch with tool definition
-  async execute(params: { cronId: string }, ctx: any) {
-    const removed = Cron.remove(params.cronId)
-
-    if (!removed) {
-      return {
-        title: "Cron task not found",
-        metadata: {},
-        output: `No cron task found with ID: ${params.cronId}`,
-      }
-    }
-
-    return {
-      title: `Deleted cron: ${params.cronId}`,
-      metadata: { cronId: params.cronId },
-      output: `Cron task ${params.cronId} has been deleted.`,
-    }
-  },
-})

package/src/tool/cron-delete.txt

@@ -1 +0,0 @@
-Delete a scheduled cron task by its ID. This stops the task from executing in the future.

package/src/tool/cron-list.ts

@@ -1,37 +0,0 @@
-import { Tool } from "./tool"
-import DESCRIPTION from "./cron-list.txt"
-import z from "zod"
-import { Cron } from "../cron"
-
-export const CronListTool = Tool.define("cron_list", {
-  description: DESCRIPTION,
-  parameters: z.object({}),
-  async execute(_params, ctx) {
-    const tasks = Cron.list()
-
-    if (tasks.length === 0) {
-      return {
-        title: "No cron tasks",
-        metadata: { count: 0 },
-        output: "No scheduled tasks found.",
-      }
-    }
-
-    const lines = tasks.map((t) => {
-      const nextRun = t.timeNextRun ? new Date(t.timeNextRun).toLocaleString() : "N/A"
-      const lastRun = t.timeLastRun ? new Date(t.timeLastRun).toLocaleString() : "never"
-      return [
-        `${t.id} [${t.expression}]`,
-        `  Agent: ${t.agent} | Recurring: ${t.recurring} | Durable: ${t.durable}`,
-        `  Next: ${nextRun} | Last: ${lastRun}`,
-        `  Prompt: ${t.prompt.slice(0, 80)}${t.prompt.length > 80 ? "..." : ""}`,
-      ].join("\n")
-    })
-
-    return {
-      title: `${tasks.length} cron task(s)`,
-      metadata: { count: tasks.length },
-      output: lines.join("\n\n"),
-    }
-  },
-})

package/src/tool/cron-list.txt

@@ -1 +0,0 @@
-List all scheduled cron tasks. Shows the cron expression, prompt, agent, and next run time for each task.