@epoch-ai/cli 2.2.4 → 2.2.5

package/src/tool/registry.ts

@@ -1,288 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

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

package/src/tool/task_complete.ts

@@ -1,21 +0,0 @@
-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,
-      },
-    }
-  },
-})