anymous 1.1.5 → 1.2.0

package/src/plugin/index.ts

@@ -163,83 +163,75 @@ const layer = Layer.effect(
           $: typeof Bun === "undefined" ? undefined : Bun.$,
         }
 
-        const internalInits = yield* Effect.all(
-          (flags.disableDefaultPlugins ? [] : internalPlugins(flags)).map((plugin) =>
-            Effect.tryPromise({
-              try: () => plugin(input),
-              catch: errorMessage,
-            }).pipe(
-              Effect.tapError((error) => Effect.logError("failed to load internal plugin", { name: plugin.name, error })),
-              Effect.option,
+        if (!flags.fastBoot) {
+          const internalInits = yield* Effect.all(
+            (flags.disableDefaultPlugins ? [] : internalPlugins(flags)).map((plugin) =>
+              Effect.tryPromise({
+                try: () => plugin(input),
+                catch: errorMessage,
+              }).pipe(
+                Effect.tapError((error) => Effect.logError("failed to load internal plugin", { name: plugin.name, error })),
+                Effect.option,
+              ),
             ),
-          ),
-          { concurrency: 10 },
-        )
-        for (const init of internalInits) {
-          if (init._tag === "Some") hooks.push(init.value)
-        }
+            { concurrency: 10 },
+          )
+          for (const init of internalInits) {
+            if (init._tag === "Some") hooks.push(init.value)
+          }
+
+          const plugins = flags.pure ? [] : (cfg.plugin_origins ?? [])
+          if (plugins.length) yield* config.waitForDependencies()
+
+          const loaded = yield* Effect.promise(() =>
+            PluginLoader.loadExternal({
+              items: plugins,
+              kind: "server",
+              report: {
+                start(candidate) {},
+                missing(candidate, _retry, message) {},
+                error(candidate, _retry, stage, error, resolved) {
+                  const spec = candidate.plan.spec
+                  const cause = error instanceof Error ? (error.cause ?? error) : error
+                  const message = stage === "load" ? errorMessage(error) : errorMessage(cause)
+
+                  if (stage === "install") {
+                    const parsed = parsePluginSpecifier(spec)
+                    publishPluginError(`Failed to install plugin ${parsed.pkg}@${parsed.version}: ${message}`)
+                    return
+                  }
+
+                  if (stage === "compatibility") {
+                    publishPluginError(`Plugin ${spec} skipped: ${message}`)
+                    return
+                  }
+
+                  if (stage === "entry") {
+                    publishPluginError(`Failed to load plugin ${spec}: ${message}`)
+                    return
+                  }
 
-        const plugins = flags.pure ? [] : (cfg.plugin_origins ?? [])
-        if (flags.pure && cfg.plugin_origins?.length) {
-        }
-        if (plugins.length) yield* config.waitForDependencies()
-
-        const loaded = yield* Effect.promise(() =>
-          PluginLoader.loadExternal({
-            items: plugins,
-            kind: "server",
-            report: {
-              start(candidate) {},
-              missing(candidate, _retry, message) {},
-              error(candidate, _retry, stage, error, resolved) {
-                const spec = candidate.plan.spec
-                const cause = error instanceof Error ? (error.cause ?? error) : error
-                const message = stage === "load" ? errorMessage(error) : errorMessage(cause)
-
-                if (stage === "install") {
-                  const parsed = parsePluginSpecifier(spec)
-                  publishPluginError(`Failed to install plugin ${parsed.pkg}@${parsed.version}: ${message}`)
-                  return
-                }
-
-                if (stage === "compatibility") {
-                  publishPluginError(`Plugin ${spec} skipped: ${message}`)
-                  return
-                }
-
-                if (stage === "entry") {
                   publishPluginError(`Failed to load plugin ${spec}: ${message}`)
-                  return
-                }
-
-                publishPluginError(`Failed to load plugin ${spec}: ${message}`)
+                },
               },
-            },
-          }),
-        )
-        for (const load of loaded) {
-          if (!load) continue
-
-          // Keep plugin execution sequential so hook registration and execution
-          // order remains deterministic across plugin runs.
-          yield* Effect.tryPromise({
-            try: () => applyPlugin(load, input, hooks),
-            catch: (err) => {
-              const message = errorMessage(err)
-              return message
-            },
-          }).pipe(
-            Effect.tapError((error) => Effect.logError("failed to load plugin", { path: load.spec, error })),
-            Effect.catch(() => {
-              // TODO: make proper events for this
-              // events.publish(Session.Event.Error, {
-              //   error: new NamedError.Unknown({
-              //     message: `Failed to load plugin ${load.spec}: ${message}`,
-              //   }).toObject(),
-              // })
-              return Effect.void
             }),
           )
+          for (const load of loaded) {
+            if (!load) continue
+
+            yield* Effect.tryPromise({
+              try: () => applyPlugin(load, input, hooks),
+              catch: (err) => {
+                const message = errorMessage(err)
+                return message
+              },
+            }).pipe(
+              Effect.tapError((error) => Effect.logError("failed to load plugin", { path: load.spec, error })),
+              Effect.catch(() => {
+                return Effect.void
+              }),
+            )
+          }
         }
 
         // Notify plugins of current config

package/src/session/prompt.ts

@@ -47,6 +47,7 @@ import { InstanceState } from "@/effect/instance-state"
 import { TaskTool, type TaskPromptOps } from "@/tool/task"
 import { SessionRunState } from "./run-state"
 import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Memory } from "@/memory/memory"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { Database } from "@anymous-ai/core/database/database"
 import { ModelV2 } from "@anymous-ai/core/model"
@@ -139,6 +140,7 @@ const layer = Layer.effect(
     const llm = yield* LLM.Service
     const events = yield* EventV2Bridge.Service
     const flags = yield* RuntimeFlags.Service
+    const memory = yield* Memory.Service
     const database = yield* Database.Service
     const { db } = database
     const ops = Effect.fn("SessionPrompt.ops")(function* () {
@@ -1254,16 +1256,18 @@ const layer = Layer.effect(
 
             yield* plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
 
-            const [skills, env, instructions, mcpInstructions, modelMsgs] = yield* Effect.all([
+            const [skills, env, instructions, mcpInstructions, modelMsgs, sharedMemory] = yield* Effect.all([
               sys.skills(agent),
               sys.environment(model),
               instruction.system().pipe(Effect.orDie),
               sys.mcp(agent, session.permission),
               MessageV2.toModelMessagesEffect(msgs, model),
+              memory.allText(),
             ])
             const system = [
               ...env,
               ...instructions,
+              ...(sharedMemory ? [sharedMemory] : []),
               ...(mcpInstructions ? [mcpInstructions] : []),
               ...(skills ? [skills] : []),
             ]
@@ -1624,6 +1628,7 @@ export const node = LayerNode.make({
     LLM.node,
     EventV2Bridge.node,
     RuntimeFlags.node,
+    Memory.node,
     Database.node,
   ],
 })

package/src/tool/computer.ts

@@ -0,0 +1,417 @@
+import { Effect, Schema, pipe } from "effect"
+import * as Tool from "./tool"
+import { spawn } from "child_process"
+import DESCRIPTION from "./computer.txt"
+
+const platform = process.platform
+
+const poweshellScript = (script: string) =>
+  Effect.promise<string>(
+    () =>
+      new Promise((resolve, reject) => {
+        const proc = spawn("powershell", [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          script,
+        ])
+        let stdout = ""
+        let stderr = ""
+        proc.stdout.on("data", (d: Buffer) => (stdout += d.toString()))
+        proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()))
+        proc.on("close", (code) => {
+          if (code === 0) resolve(stdout.trim())
+          else reject(new Error(stderr.trim() || `exit code ${code}`))
+        })
+        proc.on("error", reject)
+      }),
+  )
+
+const captureScreenshot = Effect.fn("Computer.screenshot")(function* () {
+  if (platform === "win32") {
+    const base64 = yield* poweshellScript(`
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Windows.Forms
+$bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+$bmp = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+$gfx = [System.Drawing.Graphics]::FromImage($bmp)
+$gfx.CopyFromScreen($bounds.X, $bounds.Y, 0, 0, $bounds.Size)
+$ms = New-Object System.IO.MemoryStream
+$bmp.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+$bytes = $ms.ToArray()
+[Convert]::ToBase64String($bytes)
+$gfx.Dispose()
+$bmp.Dispose()
+$ms.Dispose()
+`)
+    return `data:image/png;base64,${base64}`
+  }
+  if (platform === "darwin") {
+    const base64 = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("screencapture", ["-x", "-t", "png", "-"])
+          const chunks: Buffer[] = []
+          proc.stdout.on("data", (d: Buffer) => chunks.push(d))
+          proc.on("close", (code) => {
+            if (code === 0) resolve(Buffer.concat(chunks).toString("base64"))
+            else reject(new Error(`screencapture exit code ${code}`))
+          })
+          proc.on("error", reject)
+        }),
+    )
+    return `data:image/png;base64,${base64}`
+  }
+  if (platform === "linux") {
+    const base64 = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("import", ["-window", "root", "png:-"])
+          const chunks: Buffer[] = []
+          proc.stdout.on("data", (d: Buffer) => chunks.push(d))
+          proc.on("close", (code) => {
+            if (code === 0) resolve(Buffer.concat(chunks).toString("base64"))
+            else reject(new Error(`import exit code ${code}`))
+          })
+          proc.on("error", reject)
+        }),
+    )
+    return `data:image/png;base64,${base64}`
+  }
+  return yield* Effect.fail(new Error(`Unsupported platform: ${platform}`))
+})
+
+const moveMouse = Effect.fn("Computer.moveMouse")(function* (x: number, y: number) {
+  if (platform === "win32") {
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)})
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to set position of mouse to {${Math.round(x)}, ${Math.round(y)}}`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["mousemove", String(Math.round(x)), String(Math.round(y))])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const clickMouse = Effect.fn("Computer.clickMouse")(function* (button: "left" | "right" | "middle") {
+  if (platform === "win32") {
+    const btn = button === "left" ? "[MouseButtons]::Left" : button === "right" ? "[MouseButtons]::Right" : "[MouseButtons]::Middle"
+    const down = button === "left" ? "0x2" : button === "right" ? "0x8" : "0x20"
+    const up = button === "left" ? "0x4" : button === "right" ? "0x10" : "0x40"
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Click()
+`)
+  } else if (platform === "darwin") {
+    const btn = button === "left" ? "click" : button === "right" ? "click at (get position of mouse) using {button 2}" : "click at (get position of mouse) using {button 3}"
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to ${btn}`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    const btn = button === "left" ? "1" : button === "right" ? "3" : "2"
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["click", btn])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const typeText = Effect.fn("Computer.typeText")(function* (text: string) {
+  if (platform === "win32") {
+    const escaped = text.replace(/"/g, '`"').replace(/\$/g, "`$").replace(/\n/g, "`n").replace(/\r/g, "`r").replace(/\t/g, "`t")
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${escaped}")
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to keystroke "${text.replace(/"/g, '\\"')}"`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["type", text])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const keyPress = Effect.fn("Computer.keyPress")(function* (keys: string[]) {
+  const combo = keys.join("+")
+  if (platform === "win32") {
+    const mapping: Record<string, string> = {
+      ctrl: "^", alt: "%", shift: "+", enter: "{ENTER}", tab: "{TAB}",
+      escape: "{ESC}", backspace: "{BACKSPACE}", delete: "{DELETE}",
+      up: "{UP}", down: "{DOWN}", left: "{LEFT}", right: "{RIGHT}",
+      home: "{HOME}", end: "{END}", pageup: "{PGUP}", pagedown: "{PGDN}",
+    }
+    const translated = keys.map((k) => mapping[k.toLowerCase()] ?? k.toUpperCase())
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${translated.join("")}")
+`)
+  } else if (platform === "darwin") {
+    const mapping: Record<string, string> = {
+      ctrl: "command down", alt: "option down", shift: "shift down",
+      enter: "return", escape: "escape", tab: "tab",
+      backspace: "delete", delete: "forward delete",
+      up: "up", down: "down", left: "left", right: "right",
+    }
+    const parts = keys.map((k) => mapping[k.toLowerCase()] ?? `"${k}"`)
+    const cmd = `tell application "System Events" to key code ${keys.length > 0 ? `using {${parts.join(", ")}}` : ""}`
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", ["-e", cmd])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["key", combo])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const scrollMouse = Effect.fn("Computer.scrollMouse")(function* (clicks: number) {
+  if (platform === "win32") {
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("{${clicks > 0 ? "UP" : "DOWN"} ${Math.abs(clicks)}}")
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to scroll wheel ${clicks} lines`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    const btn = clicks > 0 ? "4" : "5"
+    const count = Math.abs(clicks)
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["click", `--repeat`, String(count), btn])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const getScreenSize = Effect.fn("Computer.screenSize")(function* () {
+  if (platform === "win32") {
+    const raw = yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+$s = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+Write-Output "$($s.Width) $($s.Height)"
+`)
+    const [w, h] = raw.split(" ").map(Number)
+    return { width: w, height: h }
+  }
+  if (platform === "darwin") {
+    const raw = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("osascript", [
+            "-e",
+            `tell application "Finder" to get bounds of window of desktop`,
+          ])
+          let d = ""
+          proc.stdout.on("data", (b: Buffer) => (d += b.toString()))
+          proc.on("close", (code) => (code === 0 ? resolve(d.trim()) : reject(new Error(`exit ${code}`))))
+          proc.on("error", reject)
+        }),
+    )
+    const [_, __, w, h] = d.split(", ").map(Number)
+    return { width: w, height: h }
+  }
+  if (platform === "linux") {
+    const raw = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("xdotool", ["getdisplaygeometry"])
+          let d = ""
+          proc.stdout.on("data", (b: Buffer) => (d += b.toString()))
+          proc.on("close", (code) => (code === 0 ? resolve(d.trim()) : reject(new Error(`exit ${code}`))))
+          proc.on("error", reject)
+        }),
+    )
+    const [w, h] = raw.split(/\s+/).map(Number)
+    return { width: w, height: h }
+  }
+  return yield* Effect.fail(new Error(`Unsupported platform: ${platform}`))
+})
+
+export const Action = Schema.Struct({
+  action: Schema.Literal("screenshot", "click", "doubleclick", "rightclick", "move", "type", "keypress", "scroll", "screensize"),
+  x: Schema.optional(Schema.Number).annotate({ description: "X coordinate for click/move actions" }),
+  y: Schema.optional(Schema.Number).annotate({ description: "Y coordinate for click/move actions" }),
+  text: Schema.optional(Schema.String).annotate({ description: "Text to type (for type action)" }),
+  keys: Schema.optional(Schema.Array(Schema.String)).annotate({ description: "Keys to press (for keypress action), e.g. ['ctrl', 'c']" }),
+  button: Schema.optional(Schema.Literal("left", "right", "middle")).annotate({ description: "Mouse button (default: left)" }),
+  clicks: Schema.optional(Schema.Number).annotate({ description: "Scroll clicks (positive=up, negative=down)" }),
+})
+
+export const ComputerTool = Tool.define<typeof Action, {}, Question.Service>(
+  "computer",
+  Effect.gen(function* () {
+    return {
+      description: DESCRIPTION,
+      parameters: Action,
+      execute: (params: Schema.Schema.Type<typeof Action>) =>
+        Effect.gen(function* () {
+          const { action } = params
+
+          if (action === "screenshot") {
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: "Captured screenshot",
+              output: "Screenshot captured. Use the image to decide the next action.",
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "move") {
+            yield* moveMouse(params.x!, params.y!)
+            return { title: "Mouse moved", output: `Mouse moved to (${params.x}, ${params.y})`, metadata: {} }
+          }
+
+          if (action === "click" || action === "doubleclick" || action === "rightclick") {
+            if (params.x != null && params.y != null) {
+              yield* moveMouse(params.x, params.y)
+            }
+            const btn = action === "rightclick" ? "right" : (params.button ?? "left")
+            yield* clickMouse(btn as "left" | "right" | "middle")
+            if (action === "doubleclick") {
+              yield* clickMouse(btn as "left" | "right" | "middle")
+            }
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `${action} at (${params.x ?? "current"}, ${params.y ?? "current"})`,
+              output: `Performed ${action}. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "type") {
+            yield* typeText(params.text!)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Typed text`,
+              output: `Typed "${params.text!.length > 50 ? params.text!.slice(0, 50) + "..." : params.text!}". Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "keypress") {
+            yield* keyPress(params.keys!)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Key press: ${params.keys!.join("+")}`,
+              output: `Pressed ${params.keys!.join("+")}. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "scroll") {
+            yield* scrollMouse(params.clicks ?? 3)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Scrolled ${params.clicks ?? 3} clicks`,
+              output: `Scrolled. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "screensize") {
+            const size = yield* getScreenSize
+            return {
+              title: "Screen size",
+              output: `Screen resolution: ${size.width}x${size.height}`,
+              metadata: {},
+            }
+          }
+
+          return {
+            title: "Unknown action",
+            output: `Unknown action: ${action}`,
+            metadata: {},
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/computer.txt

@@ -0,0 +1,16 @@
+Control the computer screen — capture screenshots, move mouse, click, type text, press keys, and scroll. Returns a screenshot after most actions so you can see the result. Use this to navigate applications, interact with UIs, fill forms, click buttons, and control the desktop.
+
+Available actions:
+- screenshot: Capture current screen (returns image, no side effects)
+- move (x, y): Move mouse to coordinates
+- click (x?, y?, button?): Click at position (default: left button)
+- doubleclick (x?, y?): Double-click at position
+- rightclick (x?, y?): Right-click at position
+- type (text): Type text at current cursor position
+- keypress (keys): Press key combination (e.g. ["ctrl", "c"], ["alt", "tab"], ["enter"])
+- scroll (clicks): Scroll up (positive) or down (negative)
+- screensize: Get screen dimensions
+
+Coordinate system: (0,0) is top-left corner of primary screen. Get screen dimensions via screensize action.
+
+Platform support: Windows (native), macOS (via screencapture + osascript), Linux (via ImageMagick + xdotool).

package/src/tool/memory.ts

@@ -0,0 +1,59 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { Memory } from "@/memory/memory"
+import DESCRIPTION from "./memory.txt"
+
+export const Parameters = Schema.Struct({
+  action: Schema.Literal("read", "write", "delete", "list").annotate({ description: "Action to perform" }),
+  key: Schema.optional(Schema.String).annotate({ description: "Memory key (required for read/write/delete)" }),
+  value: Schema.optional(Schema.String).annotate({ description: "Memory value (required for write)" }),
+})
+
+export const MemoryTool = Tool.define<typeof Parameters, {}, Memory.Service>(
+  "memory",
+  Effect.gen(function* () {
+    const memory = yield* Memory.Service
+
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (params: Schema.Schema.Type<typeof Parameters>) =>
+        Effect.gen(function* () {
+          const { action, key, value } = params
+
+          if (action === "list") {
+            const entries = yield* memory.list()
+            if (entries.length === 0) {
+              return { title: "No memories", output: "No memories stored.", metadata: {} }
+            }
+            const formatted = entries.map((e) => `- ${e.key}: ${e.value}`).join("\n")
+            return { title: `Listed ${entries.length} memories`, output: formatted, metadata: {} }
+          }
+
+          if (action === "read") {
+            if (!key) return { title: "Error", output: "Key is required for read action.", metadata: {} }
+            const entry = yield* memory.read(key)
+            if (!entry) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
+            return { title: `Read memory: ${key}`, output: entry.value, metadata: {} }
+          }
+
+          if (action === "write") {
+            if (!key || !value) {
+              return { title: "Error", output: "Both key and value are required for write action.", metadata: {} }
+            }
+            yield* memory.write(key, value)
+            return { title: `Memory saved: ${key}`, output: `Saved memory "${key}".`, metadata: {} }
+          }
+
+          if (action === "delete") {
+            if (!key) return { title: "Error", output: "Key is required for delete action.", metadata: {} }
+            const deleted = yield* memory.delete(key)
+            if (!deleted) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
+            return { title: `Memory deleted: ${key}`, output: `Deleted memory "${key}".`, metadata: {} }
+          }
+
+          return { title: "Unknown action", output: `Unknown action: ${action}`, metadata: {} }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)