@farhanic017/octocode 3.5.0

package/src/tool/mcp-websearch.ts

@@ -0,0 +1,96 @@
+import { Duration, Effect, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+
+export const EXA_URL = process.env.EXA_API_KEY
+  ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
+  : "https://mcp.exa.ai/mcp"
+export const PARALLEL_URL = "https://search.parallel.ai/mcp"
+
+const McpResult = Schema.Struct({
+  result: Schema.Struct({
+    content: Schema.Array(
+      Schema.Struct({
+        type: Schema.String,
+        text: Schema.String,
+      }),
+    ),
+  }),
+})
+
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
+
+const parsePayload = (payload: string) =>
+  Effect.gen(function* () {
+    const trimmed = payload.trim()
+    if (!trimmed.startsWith("{")) return undefined
+    const data = yield* decode(trimmed)
+    return data.result.content.find((item) => item.text)?.text
+  })
+
+export const parseResponse = Effect.fn("McpWebSearch.parseResponse")(function* (body: string) {
+  const trimmed = body.trim()
+  const direct = trimmed ? yield* parsePayload(trimmed) : undefined
+  if (direct) return direct
+
+  for (const line of body.split("\n")) {
+    if (!line.startsWith("data: ")) continue
+    const data = yield* parsePayload(line.substring(6))
+    if (data) return data
+  }
+  return undefined
+})
+
+export const SearchArgs = Schema.Struct({
+  query: Schema.String,
+  type: Schema.String,
+  numResults: Schema.Number,
+  livecrawl: Schema.String,
+  contextMaxCharacters: Schema.optional(Schema.Number),
+})
+
+export const ParallelSearchArgs = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  session_id: Schema.optional(Schema.String),
+  model_name: Schema.optional(Schema.String),
+})
+
+const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
+  Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({
+      name: Schema.String,
+      arguments: args,
+    }),
+  })
+
+export const call = <F extends Schema.Struct.Fields>(
+  http: HttpClient.HttpClient,
+  url: string,
+  tool: string,
+  args: Schema.Struct<F>,
+  value: Schema.Struct.Type<F>,
+  timeout: Duration.Input,
+  headers?: Record<string, string>,
+) =>
+  Effect.gen(function* () {
+    const request = yield* HttpClientRequest.post(url).pipe(
+      HttpClientRequest.accept("application/json, text/event-stream"),
+      HttpClientRequest.setHeaders(headers ?? {}),
+      HttpClientRequest.schemaBodyJson(McpRequest(args))({
+        jsonrpc: "2.0" as const,
+        id: 1 as const,
+        method: "tools/call" as const,
+        params: { name: tool, arguments: value },
+      }),
+    )
+    const response = yield* HttpClient.filterStatusOk(http)
+      .execute(request)
+      .pipe(
+        Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error(`${tool} request timed out`)) }),
+      )
+    const body = yield* response.text
+    return yield* parseResponse(body)
+  })

package/src/tool/open_app.ts

@@ -0,0 +1,55 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  app: Schema.String,
+  args: Schema.optional(Schema.Array(Schema.String)),
+})
+
+async function launchApp(params: { app: string; args?: string[] }) {
+  const { execSync } = await import("child_process")
+  const args = params.args?.join(" ") ?? ""
+
+  if (process.platform === "win32") {
+    execSync(`Start-Process "${params.app}" ${args}`, { shell: "powershell" })
+  } else if (process.platform === "darwin") {
+    execSync(`open -a "${params.app}" ${args}`)
+  } else {
+    execSync(`${params.app} ${args} &`, { shell: "bash" })
+  }
+}
+
+export const OpenAppTool = Tool.define(
+  "open_app",
+  Effect.gen(function* () {
+    return {
+      description: "Open any desktop application by name (e.g., 'chrome', 'notepad', 'vscode').",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "open_app",
+            patterns: [params.app],
+            always: [`open_app:${params.app}`],
+            metadata: { app: params.app, args: params.args },
+          })
+
+          try {
+            yield* Effect.promise(() => launchApp(params))
+
+            return {
+              title: `Opened ${params.app}`,
+              metadata: { app: params.app },
+              output: `Application ${params.app} launched successfully.`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to open ${params.app}`,
+              metadata: { app: params.app },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/open_terminal.ts

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  command: Schema.optional(Schema.String),
+  cwd: Schema.optional(Schema.String),
+  shell: Schema.optional(Schema.Literals(["powershell", "cmd", "bash"])),
+})
+
+async function openNewTerminal(params: { command?: string; cwd?: string; shell?: string }) {
+  const { execSync } = await import("child_process")
+  const shell = params.shell ?? "powershell"
+  const cwd = params.cwd ?? process.cwd()
+
+  if (process.platform === "win32") {
+    if (shell === "powershell") {
+      execSync(`wt -d "${cwd}" powershell -NoLogo`, { shell: "powershell" })
+    } else if (shell === "cmd") {
+      execSync(`wt -d "${cwd}" cmd`, { shell: "powershell" })
+    }
+  } else if (process.platform === "darwin") {
+    execSync(`open -a Terminal "${cwd}"`)
+  } else {
+    execSync(`gnome-terminal --working-directory="${cwd}"`, { shell: "bash" })
+  }
+
+  if (params.command) {
+    await new Promise((r) => setTimeout(r, 500))
+    const { keyboard } = await import("@nut-tree-fork/nut-js")
+    await keyboard.type(params.command)
+    await keyboard.pressKey("Enter")
+  }
+}
+
+export const OpenTerminalTool = Tool.define(
+  "open_terminal",
+  Effect.gen(function* () {
+    return {
+      description:
+        "Open a new terminal window and optionally run a command. Supports PowerShell, CMD, and Bash.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "open_terminal",
+            patterns: ["open_terminal"],
+            always: ["open_terminal"],
+            metadata: { command: params.command, cwd: params.cwd, shell: params.shell },
+          })
+
+          try {
+            yield* Effect.promise(() => openNewTerminal(params))
+
+            return {
+              title: "Terminal opened",
+              metadata: { shell: params.shell ?? "powershell", cwd: params.cwd ?? process.cwd() },
+              output: `New ${params.shell ?? "powershell"} terminal opened at ${params.cwd ?? process.cwd()}${params.command ? `. Running: ${params.command}` : ""}`,
+            }
+          } catch (error) {
+            return {
+              title: "Failed to open terminal",
+              metadata: {},
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/plan-enter.txt

@@ -0,0 +1,14 @@
+Use this tool to suggest switching to plan agent when the user's request would benefit from planning before implementation.
+
+If they explicitly mention wanting to create a plan ALWAYS call this tool first.
+
+This tool will ask the user if they want to switch to plan agent.
+
+Call this tool when:
+- The user's request is complex and would benefit from planning first
+- You want to research and design before making changes
+- The task involves multiple files or significant architectural decisions
+
+Do NOT call this tool:
+- For simple, straightforward tasks
+- When the user explicitly wants immediate implementation

package/src/tool/plan-exit.txt

@@ -0,0 +1,13 @@
+Use this tool when you have completed the planning phase and are ready to exit plan agent.
+
+This tool will ask the user if they want to switch to build agent to start implementing the plan.
+
+Call this tool:
+- After you have written a complete plan to the plan file
+- After you have clarified any questions with the user
+- When you are confident the plan is ready for implementation
+
+Do NOT call this tool:
+- Before you have created or finalized the plan
+- If you still have unanswered questions about the implementation
+- If the user has indicated they want to continue planning

package/src/tool/plan.ts

@@ -0,0 +1,79 @@
+import path from "path"
+import { SessionV1 } from "@octocode-ai/core/v1/session"
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { Question } from "../question"
+import { Session } from "@/session/session"
+import { MessageV2 } from "../session/message-v2"
+import { Provider } from "@/provider/provider"
+import { InstanceState } from "@/effect/instance-state"
+import { MessageID, PartID } from "../session/schema"
+import EXIT_DESCRIPTION from "./plan-exit.txt"
+
+export const Parameters = Schema.Struct({})
+
+export const PlanExitTool = Tool.define(
+  "plan_exit",
+  Effect.gen(function* () {
+    const session = yield* Session.Service
+    const question = yield* Question.Service
+    const provider = yield* Provider.Service
+
+    return {
+      description: EXIT_DESCRIPTION,
+      parameters: Parameters,
+      execute: (_params: {}, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const instance = yield* InstanceState.context
+          const info = yield* session.get(ctx.sessionID)
+          const plan = path.relative(instance.worktree, Session.plan(info, instance))
+          const answers = yield* question.ask({
+            sessionID: ctx.sessionID,
+            questions: [
+              {
+                question: `Plan at ${plan} is complete. Would you like to switch to the build agent and start implementing?`,
+                header: "Build Agent",
+                custom: false,
+                options: [
+                  { label: "Yes", description: "Switch to build agent and start implementing the plan" },
+                  { label: "No", description: "Stay with plan agent to continue refining the plan" },
+                ],
+              },
+            ],
+            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+          })
+
+          if (answers[0]?.[0] === "No") yield* new Question.RejectedError()
+
+          const messages = yield* session.messages({ sessionID: ctx.sessionID }).pipe(Effect.orDie)
+          const lastUser = messages.findLast((item) => item.info.role === "user" && item.info.model)
+          const model =
+            lastUser?.info.role === "user" && lastUser.info.model ? lastUser.info.model : yield* provider.defaultModel()
+
+          const msg: SessionV1.User = {
+            id: MessageID.ascending(),
+            sessionID: ctx.sessionID,
+            role: "user",
+            time: { created: Date.now() },
+            agent: "build",
+            model,
+          }
+          yield* session.updateMessage(msg)
+          yield* session.updatePart({
+            id: PartID.ascending(),
+            messageID: msg.id,
+            sessionID: ctx.sessionID,
+            type: "text",
+            text: `The plan at ${plan} has been approved, you can now edit files. Execute the plan`,
+            synthetic: true,
+          } satisfies SessionV1.TextPart)
+
+          return {
+            title: "Switching to build agent",
+            output: "User approved switching to build agent. Wait for further instructions.",
+            metadata: {},
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/question.ts

@@ -0,0 +1,44 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { Question } from "../question"
+import DESCRIPTION from "./question.txt"
+
+export const Parameters = Schema.Struct({
+  questions: Schema.mutable(Schema.Array(Question.Prompt)).annotate({ description: "Questions to ask" }),
+})
+
+type Metadata = {
+  answers: ReadonlyArray<Question.Answer>
+}
+
+export const QuestionTool = Tool.define<typeof Parameters, Metadata, Question.Service>(
+  "question",
+  Effect.gen(function* () {
+    const question = yield* Question.Service
+
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context<Metadata>) =>
+        Effect.gen(function* () {
+          const answers = yield* question.ask({
+            sessionID: ctx.sessionID,
+            questions: params.questions,
+            tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+          })
+
+          const formatted = params.questions
+            .map((q, i) => `"${q.question}"="${answers[i]?.length ? answers[i].join(", ") : "Unanswered"}"`)
+            .join(", ")
+
+          return {
+            title: `Asked ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
+            output: `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`,
+            metadata: {
+              answers,
+            },
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/question.txt

@@ -0,0 +1,10 @@
+Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- When `custom` is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set `multiple: true` to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label