@bloxystudios/bloxycode 1.0.2 → 1.0.5

package/src/tool/batch.ts

@@ -1,175 +0,0 @@
-import z from "zod"
-import { Tool } from "./tool"
-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 { Identifier } = await import("../id/id")
-
-      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: "", providerID: "" })
-      const toolMap = new Map(availableTools.map((t) => [t.id, t]))
-
-      const executeCall = async (call: (typeof toolCalls)[0]) => {
-        const callStartTime = Date.now()
-        const partID = Identifier.ascending("part")
-
-        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 })
-
-          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: result.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: error instanceof Error ? error.message : String(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 = Identifier.ascending("part")
-        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/bloxy-control.ts

@@ -1,123 +0,0 @@
-import z from "zod"
-import { Tool } from "./tool"
-import { BloxyState } from "../bloxy/state"
-import { BloxyEvent } from "../bloxy/event"
-import { Instance } from "../project/instance"
-import { Log } from "../util/log"
-import { Bus } from "../bus"
-
-import DESCRIPTION from "./bloxy-control.txt"
-
-const log = Log.create({ service: "tool.bloxy-control" })
-
-const Parameters = z.object({
-  action: z
-    .enum(["task_complete", "task_failed", "run_tests"])
-    .describe("The action to perform: task_complete, task_failed, or run_tests"),
-  summary: z
-    .string()
-    .optional()
-    .describe("For task_complete: brief summary of what was accomplished"),
-  error: z
-    .string()
-    .optional()
-    .describe("For task_failed: error message describing what went wrong"),
-})
-
-export const BloxyControlTool = Tool.define<
-  typeof Parameters,
-  { action: string; taskId?: string }
->("bloxy_control", {
-  description: DESCRIPTION,
-  parameters: Parameters,
-  async execute(args, ctx) {
-    const worktree = Instance.worktree
-    const session = await BloxyState.load(worktree)
-
-    if (!session) {
-      return {
-        title: "No bloxy session",
-        metadata: { action: args.action },
-        output: "No active Bloxy session found. Use /bloxy PRD.md to start one.",
-      }
-    }
-
-    const task = BloxyState.getCurrentTask(session)
-    if (!task) {
-      return {
-        title: "No current task",
-        metadata: { action: args.action },
-        output: "No current task in the Bloxy session. All tasks may be complete.",
-      }
-    }
-
-    switch (args.action) {
-      case "task_complete": {
-        await BloxyState.markComplete(worktree, session, task.id, args.summary)
-
-        // Publish event for session loop to continue
-        await Bus.publish(BloxyEvent.TaskComplete, { sessionID: ctx.sessionID, taskId: task.id, summary: args.summary })
-
-        const remaining = BloxyState.countRemaining(session)
-        log.info("Task marked complete", { taskId: task.id, remaining })
-
-        return {
-          title: `Task completed: ${task.title}`,
-          metadata: { action: args.action, taskId: task.id },
-          output: remaining > 0
-            ? `Task "${task.title}" completed successfully. ${remaining} task(s) remaining.`
-            : `Task "${task.title}" completed. All tasks done!`,
-        }
-      }
-
-      case "task_failed": {
-        await BloxyState.markFailed(worktree, session, task.id, args.error)
-
-        // Publish event for session loop to handle retry/continue
-        await Bus.publish(BloxyEvent.TaskFailed, { sessionID: ctx.sessionID, taskId: task.id, error: args.error })
-
-        const updatedSession = await BloxyState.load(worktree)
-        const updatedTask = updatedSession?.tasks.find(t => t.id === task.id)
-
-        log.error("Task marked failed", { taskId: task.id, error: args.error })
-
-        if (updatedTask?.status === "pending") {
-          return {
-            title: `Task failed (will retry): ${task.title}`,
-            metadata: { action: args.action, taskId: task.id },
-            output: `Task "${task.title}" failed: ${args.error || "Unknown error"}. Will retry (attempt ${updatedTask.attempts}/${session.config.maxRetries}).`,
-          }
-        }
-
-        return {
-          title: `Task failed: ${task.title}`,
-          metadata: { action: args.action, taskId: task.id },
-          output: `Task "${task.title}" failed after ${session.config.maxRetries} attempts: ${args.error || "Unknown error"}.`,
-        }
-      }
-
-      case "run_tests": {
-        if (!session.config.testCommand) {
-          return {
-            title: "No test command configured",
-            metadata: { action: args.action },
-            output: "No test command is configured in the Bloxy session. Tests skipped.",
-          }
-        }
-
-        return {
-          title: "Run tests",
-          metadata: { action: args.action },
-          output: `Please run the test command: ${session.config.testCommand}`,
-        }
-      }
-
-      default:
-        return {
-          title: "Unknown action",
-          metadata: { action: args.action },
-          output: `Unknown bloxy_control action: ${args.action}. Valid actions: task_complete, task_failed, run_tests`,
-        }
-    }
-  },
-})

package/src/tool/bloxy-control.txt

@@ -1,13 +0,0 @@
-Signal task completion or failure in Bloxy autonomous mode.
-
-Use this tool to:
-- Signal that the current task has been completed successfully
-- Signal that the current task has failed
-- Request test execution
-
-Actions:
-- `task_complete`: Mark the current task as complete. Include a brief `summary` of what was accomplished.
-- `task_failed`: Mark the current task as failed. Include the `error` message describing what went wrong.
-- `run_tests`: Request that tests be run (if configured).
-
-This tool is only available when operating in Bloxy mode (autonomous task execution). After calling task_complete or task_failed, the system will automatically advance to the next task or complete the session.

package/src/tool/codesearch.ts

@@ -1,132 +0,0 @@
-import z from "zod"
-import { Tool } from "./tool"
-import DESCRIPTION from "./codesearch.txt"
-
-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 controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), 30000)
-
-    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: AbortSignal.any([controller.signal, ctx.abort]),
-      })
-
-      clearTimeout(timeoutId)
-
-      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(timeoutId)
-
-      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'