@farhanic017/octocode 3.5.0

package/src/tool/apply_patch.txt

@@ -0,0 +1,33 @@
+Use the `apply_patch` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+```
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+```
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with `+` even when creating a new file

package/src/tool/browser_click.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  selector: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserClickTool = Tool.define(
+  "browser_click",
+  Effect.gen(function* () {
+    return {
+      description: "Click an element in the browser by CSS selector.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_click",
+            patterns: [params.selector],
+            always: [`browser_click:${params.selector}`],
+            metadata: { selector: params.selector },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            yield* Effect.promise(() => page.click(params.selector))
+
+            return {
+              title: `Clicked ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Clicked element: ${params.selector}`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to click ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_drag.ts

@@ -0,0 +1,76 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  source: Schema.String,
+  target: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserDragTool = Tool.define(
+  "browser_drag",
+  Effect.gen(function* () {
+    return {
+      description: "Drag an element from source to target in the browser by CSS selectors.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_drag",
+            patterns: [params.source, params.target],
+            always: [`browser_drag:${params.source}:${params.target}`],
+            metadata: { source: params.source, target: params.target },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            const sourceEl = yield* Effect.promise(() => page.$(params.source))
+            const targetEl = yield* Effect.promise(() => page.$(params.target))
+
+            if (sourceEl && targetEl) {
+              const sourceBox = yield* Effect.promise(() => sourceEl.boundingBox())
+              const targetBox = yield* Effect.promise(() => targetEl.boundingBox())
+
+              if (sourceBox && targetBox) {
+                yield* Effect.promise(() =>
+                  page.mouse.move(
+                    sourceBox.x + sourceBox.width / 2,
+                    sourceBox.y + sourceBox.height / 2,
+                  ),
+                )
+                yield* Effect.promise(() => page.mouse.down())
+                yield* Effect.promise(() =>
+                  page.mouse.move(
+                    targetBox.x + targetBox.width / 2,
+                    targetBox.y + targetBox.height / 2,
+                    { steps: 10 },
+                  ),
+                )
+                yield* Effect.promise(() => page.mouse.up())
+              }
+            }
+
+            return {
+              title: `Dragged from ${params.source} to ${params.target}`,
+              metadata: { source: params.source, target: params.target },
+              output: `Dragged element from ${params.source} to ${params.target}`,
+            }
+          } catch (error) {
+            return {
+              title: "Drag failed",
+              metadata: { source: params.source, target: params.target },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_evaluate.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  script: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserEvaluateTool = Tool.define(
+  "browser_evaluate",
+  Effect.gen(function* () {
+    return {
+      description: "Execute JavaScript in the browser and return the result.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_evaluate",
+            patterns: ["browser_evaluate"],
+            always: ["browser_evaluate"],
+            metadata: { script: params.script },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            const result = yield* Effect.promise(() => page.evaluate(params.script))
+
+            return {
+              title: "Script executed",
+              metadata: { script: params.script },
+              output: `Result: ${JSON.stringify(result)}`,
+            }
+          } catch (error) {
+            return {
+              title: "Script execution failed",
+              metadata: { script: params.script },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_hover.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  selector: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserHoverTool = Tool.define(
+  "browser_hover",
+  Effect.gen(function* () {
+    return {
+      description: "Hover over an element in the browser by CSS selector.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_hover",
+            patterns: [params.selector],
+            always: [`browser_hover:${params.selector}`],
+            metadata: { selector: params.selector },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            yield* Effect.promise(() => page.hover(params.selector))
+
+            return {
+              title: `Hovered over ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Hovered over element: ${params.selector}`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to hover over ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_navigate.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  url: Schema.String,
+})
+
+export const BrowserNavigateTool = Tool.define(
+  "browser_navigate",
+  Effect.gen(function* () {
+    return {
+      description: "Navigate to a URL in the browser.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_navigate",
+            patterns: [params.url],
+            always: [`browser_navigate:${params.url}`],
+            metadata: { url: params.url },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+            yield* Effect.promise(() => page.goto(params.url))
+
+            return {
+              title: `Navigated to ${params.url}`,
+              metadata: { url: params.url },
+              output: `Opened ${params.url} in browser.`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to navigate to ${params.url}`,
+              metadata: { url: params.url },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_screenshot.ts

@@ -0,0 +1,66 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  url: Schema.optional(Schema.String),
+  selector: Schema.optional(Schema.String),
+  format: Schema.optional(Schema.Literals(["png", "jpg"])),
+})
+
+export const BrowserScreenshotTool = Tool.define(
+  "browser_screenshot",
+  Effect.gen(function* () {
+    return {
+      description: "Capture a screenshot of the browser viewport or a specific element.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_screenshot",
+            patterns: ["browser_screenshot"],
+            always: ["browser_screenshot"],
+            metadata: { url: params.url, selector: params.selector },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            let screenshot: Buffer
+            if (params.selector) {
+              const element = yield* Effect.promise(() => page.$(params.selector))
+              if (element) {
+                screenshot = yield* Effect.promise(() => element.screenshot())
+              } else {
+                screenshot = yield* Effect.promise(() => page.screenshot())
+              }
+            } else {
+              screenshot = yield* Effect.promise(() => page.screenshot())
+            }
+
+            const base64 = screenshot.toString("base64")
+            const format = params.format ?? "png"
+
+            return {
+              title: "Browser screenshot captured",
+              metadata: { format, selector: params.selector },
+              output: `Screenshot captured. Base64 length: ${base64.length}`,
+              attachments: [{ type: "image" as const, data: base64, mimeType: `image/${format}` }],
+            }
+          } catch (error) {
+            return {
+              title: "Browser screenshot failed",
+              metadata: {},
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_select.ts

@@ -0,0 +1,52 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  selector: Schema.String,
+  value: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserSelectTool = Tool.define(
+  "browser_select",
+  Effect.gen(function* () {
+    return {
+      description: "Select an option from a dropdown in the browser by CSS selector and value.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_select",
+            patterns: [params.selector],
+            always: [`browser_select:${params.selector}`],
+            metadata: { selector: params.selector, value: params.value },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            yield* Effect.promise(() => page.selectOption(params.selector, params.value))
+
+            return {
+              title: `Selected "${params.value}" in ${params.selector}`,
+              metadata: { selector: params.selector, value: params.value },
+              output: `Selected "${params.value}" in ${params.selector}`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to select in ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_type.ts

@@ -0,0 +1,52 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  selector: Schema.String,
+  text: Schema.String,
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserTypeTool = Tool.define(
+  "browser_type",
+  Effect.gen(function* () {
+    return {
+      description: "Type text into an input field in the browser by CSS selector.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_type",
+            patterns: [params.selector],
+            always: [`browser_type:${params.selector}`],
+            metadata: { selector: params.selector, text: params.text },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            yield* Effect.promise(() => page.fill(params.selector, params.text))
+
+            return {
+              title: `Typed into ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Typed "${params.text}" into ${params.selector}`,
+            }
+          } catch (error) {
+            return {
+              title: `Failed to type into ${params.selector}`,
+              metadata: { selector: params.selector },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/browser_wait.ts

@@ -0,0 +1,60 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+export const Parameters = Schema.Struct({
+  selector: Schema.optional(Schema.String),
+  timeout: Schema.optional(Schema.Number),
+  url: Schema.optional(Schema.String),
+})
+
+export const BrowserWaitTool = Tool.define(
+  "browser_wait",
+  Effect.gen(function* () {
+    return {
+      description: "Wait for an element to appear or a condition to be met in the browser.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "browser_wait",
+            patterns: ["browser_wait"],
+            always: ["browser_wait"],
+            metadata: { selector: params.selector, timeout: params.timeout },
+          })
+
+          try {
+            const { chromium } = yield* Effect.promise(() => import("playwright"))
+
+            const browser = yield* Effect.promise(() => chromium.launch({ headless: false }))
+            const page = yield* Effect.promise(() => browser.newPage())
+
+            if (params.url) {
+              yield* Effect.promise(() => page.goto(params.url))
+            }
+
+            const timeout = params.timeout ?? 30000
+
+            if (params.selector) {
+              yield* Effect.promise(() => page.waitForSelector(params.selector, { timeout }))
+            } else {
+              yield* Effect.promise(() => page.waitForLoadState("networkidle", { timeout }))
+            }
+
+            return {
+              title: "Wait completed",
+              metadata: { selector: params.selector, timeout },
+              output: params.selector
+                ? `Element ${params.selector} appeared`
+                : "Page loaded",
+            }
+          } catch (error) {
+            return {
+              title: "Wait failed",
+              metadata: { selector: params.selector },
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)

package/src/tool/desktop_clipboard.ts

@@ -0,0 +1,82 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+
+const ClipboardActionSchema = Schema.Union([
+  Schema.Struct({
+    action: Schema.Literal("copy"),
+  }),
+  Schema.Struct({
+    action: Schema.Literal("paste"),
+  }),
+  Schema.Struct({
+    action: Schema.Literal("get"),
+  }),
+  Schema.Struct({
+    action: Schema.Literal("set"),
+    text: Schema.String,
+  }),
+])
+
+export const Parameters = Schema.Struct({
+  clipboard: ClipboardActionSchema,
+})
+
+export const DesktopClipboardTool = Tool.define(
+  "desktop_clipboard",
+  Effect.gen(function* () {
+    return {
+      description: "Read from or write to the system clipboard.",
+      parameters: Parameters,
+      execute: (params, ctx) =>
+        Effect.gen(function* () {
+          yield* ctx.ask({
+            permission: "desktop_clipboard",
+            patterns: ["desktop_clipboard"],
+            always: ["desktop_clipboard"],
+            metadata: { clipboard: params.clipboard },
+          })
+
+          try {
+            const { clipboard } = yield* Effect.promise(() => import("@nut-tree-fork/nut-js"))
+
+            let output: string
+
+            switch (params.clipboard.action) {
+              case "copy": {
+                const text = yield* Effect.promise(() => clipboard.getContent())
+                output = `Copied to clipboard: "${text}"`
+                break
+              }
+              case "paste": {
+                yield* Effect.promise(() => clipboard.copyPaste())
+                output = "Pasted from clipboard"
+                break
+              }
+              case "get": {
+                const content = yield* Effect.promise(() => clipboard.getContent())
+                output = `Clipboard content: "${content}"`
+                break
+              }
+              case "set": {
+                yield* Effect.promise(() => clipboard.setContent(params.clipboard.text))
+                output = `Set clipboard to: "${params.clipboard.text}"`
+                break
+              }
+            }
+
+            return {
+              title: `Clipboard: ${params.clipboard.action}`,
+              metadata: { action: params.clipboard.action },
+              output,
+            }
+          } catch (error) {
+            return {
+              title: "Clipboard error",
+              metadata: {},
+              output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            }
+          }
+        }),
+    }
+  }),
+)