@epoch-ai/cli 2.2.5 → 2.2.7

package/src/tool/registry.ts

@@ -0,0 +1,288 @@
+import { PlanExitTool } from "./plan"
+import { QuestionTool } from "./question"
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { RevertFileTool } from "./revert"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { BatchTool } from "./batch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+import { TaskCompleteTool } from "./task_complete"
+import { InvalidTool } from "./invalid"
+import { SkillTool } from "./skill"
+import type { Agent } from "../agent/agent"
+import { Tool } from "./tool"
+import { Config } from "../config/config"
+import path from "path"
+import { type ToolContext as PluginToolContext, type ToolDefinition } from "@epoch-ai/plugin"
+import z from "zod"
+import { Plugin } from "../plugin"
+import { ProviderID, type ModelID } from "../provider/schema"
+import { WebSearchTool } from "./websearch"
+import { CodeSearchTool } from "./codesearch"
+import { Flag } from "@/flag/flag"
+import { Log } from "@/util/log"
+import { LspTool } from "./lsp"
+import { Truncate } from "./truncate"
+import { ApplyPatchTool } from "./apply_patch"
+import { Glob } from "../util/glob"
+import { pathToFileURL } from "url"
+import { Effect, Layer, ServiceMap } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { Env } from "../env"
+import { Question } from "../question"
+import { Todo } from "../session/todo"
+import { LSP } from "../lsp"
+import { FileTime } from "../file/time"
+import { Instruction } from "../session/instruction"
+import { AppFileSystem } from "../filesystem"
+import { MCP } from "../mcp"
+import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
+
+export namespace ToolRegistry {
+  const log = Log.create({ service: "tool.registry" })
+
+  type State = {
+    custom: Tool.Info[]
+  }
+
+  export interface Interface {
+    readonly ids: () => Effect.Effect<string[]>
+    readonly named: {
+      task: Tool.Info
+      read: Tool.Info
+    }
+    readonly tools: (
+      model: { providerID: ProviderID; modelID: ModelID },
+      agent?: Agent.Info,
+    ) => Effect.Effect<(Tool.Def & { id: string })[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@epochcli/ToolRegistry") {}
+
+  export const layer: Layer.Layer<
+    Service,
+    never,
+    | Config.Service
+    | Plugin.Service
+    | Question.Service
+    | Todo.Service
+    | LSP.Service
+    | FileTime.Service
+    | Instruction.Service
+    | AppFileSystem.Service
+    | MCP.Service
+  > = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const config = yield* Config.Service
+      const plugin = yield* Plugin.Service
+      const mcp = yield* MCP.Service
+
+      const build = <T extends Tool.Info>(tool: T | Effect.Effect<T, never, any>) =>
+        Effect.isEffect(tool) ? tool : Effect.succeed(tool)
+
+      const state = yield* InstanceState.make<State>(
+        Effect.fn("ToolRegistry.state")(function* (ctx) {
+          const custom: Tool.Info[] = []
+
+          function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+            return {
+              id,
+              init: async (initCtx) => ({
+                parameters: z.object(def.args),
+                description: def.description,
+                execute: async (args, toolCtx) => {
+                  const pluginCtx = {
+                    ...toolCtx,
+                    directory: ctx.directory,
+                    worktree: ctx.worktree,
+                  } as unknown as PluginToolContext
+                  const result = await def.execute(args as any, pluginCtx)
+                  const out = await Truncate.output(result, {}, initCtx?.agent)
+                  return {
+                    title: "",
+                    output: out.truncated ? out.content : result,
+                    metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : undefined },
+                  }
+                },
+              }),
+            }
+          }
+
+          const dirs = yield* config.directories()
+          const matches = dirs.flatMap((dir) =>
+            Glob.scanSync("{tool,tools}/*.{js,ts}", { cwd: dir, absolute: true, dot: true, symlink: true }),
+          )
+          if (matches.length) yield* config.waitForDependencies()
+          for (const match of matches) {
+            const namespace = path.basename(match, path.extname(match))
+            const mod = yield* Effect.promise(
+              () => import(process.platform === "win32" ? match : pathToFileURL(match).href),
+            )
+            for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
+              custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+            }
+          }
+
+          const plugins = yield* plugin.list()
+          for (const p of plugins) {
+            for (const [id, def] of Object.entries(p.tool ?? {})) {
+              custom.push(fromPlugin(id, def))
+            }
+          }
+
+          return { custom }
+        }),
+      )
+
+      const invalid = yield* build(InvalidTool)
+      const ask = yield* build(QuestionTool)
+      const bash = yield* build(BashTool)
+      const read = yield* build(ReadTool)
+      const glob = yield* build(GlobTool)
+      const grep = yield* build(GrepTool)
+      const edit = yield* build(EditTool)
+      const revert = yield* build(RevertFileTool)
+      const write = yield* build(WriteTool)
+      const task = yield* build(TaskTool)
+      const fetch = yield* build(WebFetchTool)
+      const search = yield* build(WebSearchTool)
+      const code = yield* build(CodeSearchTool)
+      const skill = yield* build(SkillTool)
+      const patch = yield* build(ApplyPatchTool)
+      const lsp = yield* build(LspTool)
+      const batch = yield* build(BatchTool)
+      const plan = yield* build(PlanExitTool)
+      const taskComplete = yield* build(TaskCompleteTool)
+
+      const all = Effect.fn("ToolRegistry.all")(function* (custom: Tool.Info[]) {
+        const cfg = yield* config.get()
+        const question = ["app", "cli", "desktop"].includes(Flag.EPOCHCLI_CLIENT) || Flag.EPOCHCLI_ENABLE_QUESTION_TOOL
+
+        const mcpxTool = yield* mcp.mcpx()
+
+        const tools: (Tool.Info | (Tool.Def & { id: string }))[] = [
+          invalid,
+          ...(question ? [ask] : []),
+          bash,
+          read,
+          glob,
+          grep,
+          edit,
+          revert,
+          write,
+          task,
+          fetch,
+          search,
+          code,
+          skill,
+          patch,
+          taskComplete,
+          ...(Flag.EPOCHCLI_EXPERIMENTAL_LSP_TOOL ? [lsp] : []),
+          ...(cfg.experimental?.batch_tool === true ? [batch] : []),
+          ...(Flag.EPOCHCLI_EXPERIMENTAL_PLAN_MODE && Flag.EPOCHCLI_CLIENT === "cli" ? [plan] : []),
+          ...custom,
+        ]
+
+        if (mcpxTool) {
+          tools.push({ id: "mcpx", ...mcpxTool })
+        } else {
+          const mcpTools = yield* mcp.tools()
+          for (const [id, def] of Object.entries(mcpTools)) {
+            tools.push({ id, ...def })
+          }
+        }
+
+        return tools
+      })
+
+      const ids = Effect.fn("ToolRegistry.ids")(function* () {
+        const s = yield* InstanceState.get(state)
+        const allTools = yield* all(s.custom)
+        return allTools.map((t) => t.id)
+      })
+
+      const tools = Effect.fn("ToolRegistry.tools")(function* (
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        const s = yield* InstanceState.get(state)
+        const allTools = yield* all(s.custom)
+        const filtered = allTools.filter((tool) => {
+          const id = tool.id
+          if (id === "codesearch" || id === "websearch") {
+            return model.providerID === ProviderID.epochcli || Flag.EPOCHCLI_ENABLE_EXA
+          }
+
+          const usePatch =
+            !!Env.get("EPOCHCLI_E2E_LLM_URL") ||
+            (model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4"))
+          if (id === "apply_patch") return usePatch
+          if (id === "edit" || id === "write" || id === "revert_file") return !usePatch
+
+          return true
+        })
+        return yield* Effect.forEach(
+          filtered,
+          Effect.fnUntraced(function* (tool: Tool.Info | (Tool.Def & { id: string })) {
+            const id = tool.id
+            using _ = log.time(id)
+            const next = "init" in tool ? yield* Effect.promise(() => tool.init({ agent })) : tool
+            const output = {
+              description: next.description,
+              parameters: next.parameters,
+            }
+            yield* plugin.trigger("tool.definition", { toolID: id }, output)
+            return {
+              id,
+              description: output.description,
+              parameters: output.parameters,
+              execute: next.execute,
+              formatValidationError: next.formatValidationError,
+            }
+          }),
+          { concurrency: "unbounded" },
+        )
+      })
+
+      return Service.of({ ids, named: { task, read }, tools })
+    }),
+  )
+
+  export const defaultLayer = Layer.unwrap(
+    Effect.sync(() =>
+      layer.pipe(
+        Layer.provide(Config.defaultLayer),
+        Layer.provide(Plugin.defaultLayer),
+        Layer.provide(Question.defaultLayer),
+        Layer.provide(Todo.defaultLayer),
+        Layer.provide(LSP.defaultLayer),
+        Layer.provide(FileTime.defaultLayer),
+        Layer.provide(Instruction.defaultLayer),
+        Layer.provide(AppFileSystem.defaultLayer),
+        Layer.provide(MCP.defaultLayer),
+      ),
+    ),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function ids() {
+    return runPromise((svc) => svc.ids())
+  }
+
+  export async function tools(
+    model: {
+      providerID: ProviderID
+      modelID: ModelID
+    },
+    agent?: Agent.Info,
+  ): Promise<(Tool.Def & { id: string })[]> {
+    return runPromise((svc) => svc.tools(model, agent))
+  }
+}

package/src/tool/revert.ts

@@ -0,0 +1,37 @@
+import { Tool } from "./tool"
+import { z } from "zod"
+import path from "path"
+import { Instance } from "../project/instance"
+import { Filesystem } from "../util/filesystem"
+
+export const RevertFileTool = Tool.define("revert_file", {
+  description: "Reverts a file to its state before the last edit tool operation (restores the .bak file).",
+  parameters: z.object({
+    filePath: z.string().describe("The absolute path to the file to revert"),
+  }),
+  async execute(params, ctx) {
+    if (!params.filePath) {
+      throw new Error("filePath is required")
+    }
+
+    const filePath = path.isAbsolute(params.filePath) ? params.filePath : path.join(Instance.directory, params.filePath)
+    const bakPath = filePath + ".bak"
+
+    const exists = await Filesystem.exists(bakPath)
+    if (!exists) {
+      throw new Error(`Backup file not found. Ensure an edit was actually made previously. Path: ${bakPath}`)
+    }
+
+    const content = await Filesystem.readText(bakPath)
+    await Filesystem.write(filePath, content)
+
+    // Optional: cleanup the backup file so we don't restore it twice
+    // await Filesystem.remove(bakPath)
+
+    return {
+      title: `${path.relative(Instance.worktree, filePath)} reverted`,
+      output: `Successfully reverted ${filePath} to its state prior to the last edit.`,
+      metadata: {},
+    }
+  },
+})

package/src/tool/schema.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect"
+import z from "zod"
+
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+
+const toolIdSchema = Schema.String.pipe(Schema.brand("ToolID"))
+
+export type ToolID = typeof toolIdSchema.Type
+
+export const ToolID = toolIdSchema.pipe(
+  withStatics((schema: typeof toolIdSchema) => ({
+    make: (id: string) => schema.makeUnsafe(id),
+    ascending: (id?: string) => schema.makeUnsafe(Identifier.ascending("tool", id)),
+    zod: Identifier.schema("tool").pipe(z.custom<ToolID>()),
+  })),
+)

package/src/tool/skill.ts

@@ -0,0 +1,105 @@
+import path from "path"
+import { pathToFileURL } from "url"
+import z from "zod"
+import { Tool } from "./tool"
+import { Skill } from "../skill"
+import { Ripgrep } from "../file/ripgrep"
+import { iife } from "@/util/iife"
+
+export const SkillTool = Tool.define("skill", async (ctx) => {
+  const list = await Skill.available(ctx?.agent)
+
+  const description =
+    list.length === 0
+      ? "Load a specialized skill that provides domain-specific instructions and workflows. No skills are currently available."
+      : [
+          "Load a specialized skill that provides domain-specific instructions and workflows.",
+          "",
+          "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
+          "",
+          "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
+          "",
+          'Tool output includes a `<skill_content name="...">` block with the loaded content.',
+          "",
+          "The following skills provide specialized sets of instructions for particular tasks",
+          "Invoke this tool to load a skill when a task matches one of the available skills listed below:",
+          "",
+          Skill.fmt(list, { verbose: false }),
+        ].join("\n")
+
+  const examples = list
+    .map((skill) => `'${skill.name}'`)
+    .slice(0, 3)
+    .join(", ")
+  const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : ""
+
+  const parameters = z.object({
+    name: z.string().describe(`The name of the skill from available_skills${hint}`),
+  })
+
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      const skill = await Skill.get(params.name)
+
+      if (!skill) {
+        const available = await Skill.all().then((x) => x.map((skill) => skill.name).join(", "))
+        throw new Error(`Skill "${params.name}" not found. Available skills: ${available || "none"}`)
+      }
+
+      await ctx.ask({
+        permission: "skill",
+        patterns: [params.name],
+        always: [params.name],
+        metadata: {},
+      })
+
+      const dir = path.dirname(skill.location)
+      const base = pathToFileURL(dir).href
+
+      const limit = 10
+      const files = await iife(async () => {
+        const arr = []
+        for await (const file of Ripgrep.files({
+          cwd: dir,
+          follow: false,
+          hidden: true,
+          signal: ctx.abort,
+        })) {
+          if (file.includes("SKILL.md")) {
+            continue
+          }
+          arr.push(path.resolve(dir, file))
+          if (arr.length >= limit) {
+            break
+          }
+        }
+        return arr
+      }).then((f) => f.map((file) => `<file>${file}</file>`).join("\n"))
+
+      return {
+        title: `Loaded skill: ${skill.name}`,
+        output: [
+          `<skill_content name="${skill.name}">`,
+          `# Skill: ${skill.name}`,
+          "",
+          skill.content.trim(),
+          "",
+          `Base directory for this skill: ${base}`,
+          "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+          "Note: file list is sampled.",
+          "",
+          "<skill_files>",
+          files,
+          "</skill_files>",
+          "</skill_content>",
+        ].join("\n"),
+        metadata: {
+          name: skill.name,
+          dir,
+        },
+      }
+    },
+  }
+})

package/src/tool/task.ts

@@ -0,0 +1,150 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task.txt"
+import z from "zod"
+import { Session } from "../session"
+import { SessionID, MessageID } from "../session/schema"
+import { MessageV2 } from "../session/message-v2"
+import { Identifier } from "../id/id"
+import { Agent } from "../agent/agent"
+import { SessionPrompt } from "../session/prompt"
+import { iife } from "@/util/iife"
+import { defer } from "@/util/defer"
+import { Config } from "../config/config"
+import { Permission } from "@/permission"
+
+const parameters = z.object({
+  description: z.string().describe("A short (3-5 words) description of the task"),
+  prompt: z.string().describe("The task for the agent to perform"),
+  subagent_type: z.string().describe("The type of specialized agent to use for this task"),
+  task_id: z.string().describe("Optional ID to resume a previous task session. Omit to start fresh.").optional(),
+  command: z.string().describe("The command that triggered this task").optional(),
+})
+
+export const TaskTool = Tool.define("task", async (ctx) => {
+  const agents = await Agent.list().then((x) => x.filter((a) => a.mode !== "primary"))
+
+  // Filter agents by permissions if agent provided
+  const caller = ctx?.agent
+  const accessibleAgents = caller
+    ? agents.filter((a) => Permission.evaluate("task", a.name, caller.permission).action !== "deny")
+    : agents
+  const list = accessibleAgents.toSorted((a, b) => a.name.localeCompare(b.name))
+
+  const description = DESCRIPTION.replace(
+    "{agents}",
+    list
+      .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
+      .join("\n"),
+  )
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      const config = await Config.get()
+
+      // Skip permission check when user explicitly invoked via @ or command subtask
+      if (!ctx.extra?.bypassAgentCheck) {
+        await ctx.ask({
+          permission: "task",
+          patterns: [params.subagent_type],
+          always: ["*"],
+          metadata: {
+            description: params.description,
+            subagent_type: params.subagent_type,
+          },
+        })
+      }
+
+      const agent = await Agent.get(params.subagent_type)
+      if (!agent) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
+
+      const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task")
+
+      const session = await iife(async () => {
+        if (params.task_id) {
+          const found = await Session.get(SessionID.make(params.task_id)).catch(() => {})
+          if (found) return found
+        }
+
+        return await Session.create({
+          parentID: ctx.sessionID,
+          title: params.description + ` (@${agent.name} subagent)`,
+          permission: [
+            ...(hasTaskPermission
+              ? []
+              : [
+                  {
+                    permission: "task" as const,
+                    pattern: "*" as const,
+                    action: "deny" as const,
+                  },
+                ]),
+            ...(config.experimental?.primary_tools?.map((t) => ({
+              pattern: "*",
+              action: "allow" as const,
+              permission: t,
+            })) ?? []),
+          ],
+        })
+      })
+      const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
+      if (msg.info.role !== "assistant") throw new Error("Not an assistant message")
+
+      const model = agent.model ?? {
+        modelID: msg.info.modelID,
+        providerID: msg.info.providerID,
+      }
+
+      ctx.metadata({
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
+        },
+      })
+
+      const messageID = MessageID.ascending()
+
+      function cancel() {
+        SessionPrompt.cancel(session.id)
+      }
+      ctx.abort.addEventListener("abort", cancel)
+      using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
+      const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
+
+      const result = await SessionPrompt.prompt({
+        messageID,
+        sessionID: session.id,
+        model: {
+          modelID: model.modelID,
+          providerID: model.providerID,
+        },
+        agent: agent.name,
+        tools: {
+          ...(hasTaskPermission ? {} : { task: false }),
+          ...Object.fromEntries((config.experimental?.primary_tools ?? []).map((t) => [t, false])),
+        },
+        parts: promptParts,
+      })
+
+      const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+
+      const output = [
+        `task_id: ${session.id} (for resuming to continue this task if needed)`,
+        "",
+        "<task_result>",
+        text,
+        "</task_result>",
+      ].join("\n")
+
+      return {
+        title: params.description,
+        metadata: {
+          sessionId: session.id,
+          model,
+        },
+        output,
+      }
+    },
+  }
+})

package/src/tool/task.txt

@@ -0,0 +1,3 @@
+Launch or resume a subagent.
+Available agents:
+{agents}

package/src/tool/task_complete.ts

@@ -0,0 +1,21 @@
+import { Tool } from "./tool"
+import z from "zod"
+
+const parameters = z.object({
+  summary: z.string().describe("A summary of the work that was completed.").optional(),
+})
+
+export const TaskCompleteTool = Tool.define("task_complete", {
+  description:
+    "Signals that you have completely finished all requested tasks and are ready to stop execution. Call this tool ONLY when there is absolutely no more work to do.",
+  parameters,
+  async execute(params) {
+    return {
+      title: "Task Complete",
+      output: "Task marked as complete. The execution loop will now exit.",
+      metadata: {
+        summary: params.summary,
+      },
+    }
+  },
+})