@vikasitai/vikasit-code 2.0.4 → 2.0.6

package/src/tool/registry.ts

@@ -0,0 +1,333 @@
+import { PlanExitTool } from "./plan"
+import { QuestionTool } from "./question"
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { BatchTool } from "./batch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { TodoWriteTool } from "./todo"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+import { InvalidTool } from "./invalid"
+import { SkillTool } from "./skill"
+import { ToolSearchTool } from "./toolsearch"
+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 "@vikasit-code/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 { TaskCreateTool } from "./task-create"
+import { TaskGetTool } from "./task-get"
+import { TaskListTool } from "./task-list"
+import { TaskUpdateTool } from "./task-update"
+import { TaskOutputTool } from "./task-output"
+import { TaskStopTool } from "./task-stop"
+import { PlanEnterTool } from "./plan"
+import { WorktreeEnterTool } from "./worktree-enter"
+import { WorktreeExitTool } from "./worktree-exit"
+import { SendMessageTool } from "./sendmessage"
+import { NotebookEditTool } from "./notebook-edit"
+import { CronCreateTool } from "./cron-create"
+import { CronListTool } from "./cron-list"
+import { CronDeleteTool } from "./cron-delete"
+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 { zodToJsonSchema } from "zod-to-json-schema"
+
+export namespace ToolRegistry {
+  const log = Log.create({ service: "tool.registry" })
+
+  type State = {
+    custom: Tool.Info[]
+  }
+
+  export interface Interface {
+    readonly register: (tool: Tool.Info) => Effect.Effect<void>
+    readonly ids: () => Effect.Effect<string[]>
+    readonly tools: (
+      model: { providerID: ProviderID; modelID: ModelID },
+      agent?: Agent.Info,
+    ) => Effect.Effect<(Tool.Def & { id: string })[]>
+    readonly deferredIds: (
+      model: { providerID: ProviderID; modelID: ModelID },
+      agent?: Agent.Info,
+    ) => Effect.Effect<string[]>
+    readonly toolsByIds: (
+      ids: string[],
+      model: { providerID: ProviderID; modelID: ModelID },
+      agent?: Agent.Info,
+    ) => Effect.Effect<(Tool.Def & { id: string })[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/ToolRegistry") {}
+
+  export const layer: Layer.Layer<Service, never, Config.Service | Plugin.Service> = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const config = yield* Config.Service
+      const plugin = yield* Plugin.Service
+
+      const cache = 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 all = Effect.fn("ToolRegistry.all")(function* (custom: Tool.Info[]) {
+        const cfg = yield* config.get()
+        const question = ["app", "cli", "desktop"].includes(Flag.VIKASIT_CLIENT) || Flag.VIKASIT_ENABLE_QUESTION_TOOL
+
+        return [
+          InvalidTool,
+          ...(question ? [QuestionTool] : []),
+          BashTool,
+          ReadTool,
+          GlobTool,
+          GrepTool,
+          EditTool,
+          WriteTool,
+          TaskTool,
+          WebFetchTool,
+          TodoWriteTool,
+          WebSearchTool,
+          CodeSearchTool,
+          SkillTool,
+          ApplyPatchTool,
+          ...(Flag.VIKASIT_EXPERIMENTAL_DEFERRED_TOOLS ? [ToolSearchTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_TASK_LIFECYCLE
+            ? [TaskCreateTool, TaskGetTool, TaskListTool, TaskUpdateTool, TaskOutputTool, TaskStopTool]
+            : []),
+          ...(cfg.experimental?.batch_tool === true ? [BatchTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_PLAN_MODE && Flag.VIKASIT_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_WORKTREE_TOOLS ? [WorktreeEnterTool, WorktreeExitTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_SENDMESSAGE ? [SendMessageTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_NOTEBOOK_EDIT ? [NotebookEditTool] : []),
+          ...(Flag.VIKASIT_EXPERIMENTAL_CRON ? [CronCreateTool, CronListTool, CronDeleteTool] : []),
+          ...custom,
+        ]
+      })
+
+      const register = Effect.fn("ToolRegistry.register")(function* (tool: Tool.Info) {
+        const state = yield* InstanceState.get(cache)
+        const idx = state.custom.findIndex((t) => t.id === tool.id)
+        if (idx >= 0) {
+          state.custom.splice(idx, 1, tool)
+          return
+        }
+        state.custom.push(tool)
+      })
+
+      const ids = Effect.fn("ToolRegistry.ids")(function* () {
+        const state = yield* InstanceState.get(cache)
+        const tools = yield* all(state.custom)
+        return tools.map((t) => t.id)
+      })
+
+      const tools = Effect.fn("ToolRegistry.tools")(function* (
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        const state = yield* InstanceState.get(cache)
+        const allTools = yield* all(state.custom)
+        const filtered = allTools.filter((tool) => {
+          if (tool.id === "codesearch" || tool.id === "websearch") {
+            return model.providerID === ProviderID.opencode || Flag.VIKASIT_ENABLE_EXA
+          }
+
+          const usePatch =
+            model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4")
+          if (tool.id === "apply_patch") return usePatch
+          if (tool.id === "edit" || tool.id === "write") return !usePatch
+
+          return true
+        })
+        return yield* Effect.forEach(
+          filtered,
+          Effect.fnUntraced(function* (tool: Tool.Info) {
+            using _ = log.time(tool.id)
+            const next = yield* Effect.promise(() => tool.init({ agent }))
+            const output = {
+              description: next.description,
+              parameters: next.parameters,
+            }
+            yield* plugin.trigger("tool.definition", { toolID: tool.id }, output)
+            return {
+              id: tool.id,
+              description: output.description,
+              parameters: output.parameters,
+              execute: next.execute,
+              formatValidationError: next.formatValidationError,
+            }
+          }),
+          { concurrency: "unbounded" },
+        )
+      })
+
+      const deferredIds = Effect.fn("ToolRegistry.deferredIds")(function* (
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        if (!Flag.VIKASIT_EXPERIMENTAL_DEFERRED_TOOLS) return []
+        const state = yield* InstanceState.get(cache)
+        const allTools = yield* all(state.custom)
+        return allTools
+          .filter((tool) => tool.deferred === true && tool.alwaysLoad !== true)
+          .map((t) => t.id)
+      })
+
+      const toolsByIds = Effect.fn("ToolRegistry.toolsByIds")(function* (
+        ids: string[],
+        model: { providerID: ProviderID; modelID: ModelID },
+        agent?: Agent.Info,
+      ) {
+        const state = yield* InstanceState.get(cache)
+        const allTools = yield* all(state.custom)
+        const matching = allTools.filter((tool) => ids.includes(tool.id))
+        return yield* Effect.forEach(
+          matching,
+          Effect.fnUntraced(function* (tool: Tool.Info) {
+            const next = yield* Effect.promise(() => tool.init({ agent }))
+            const output = { description: next.description, parameters: next.parameters }
+            yield* plugin.trigger("tool.definition", { toolID: tool.id }, output)
+            return {
+              id: tool.id,
+              description: output.description,
+              parameters: output.parameters,
+              execute: next.execute,
+              formatValidationError: next.formatValidationError,
+            }
+          }),
+          { concurrency: "unbounded" },
+        )
+      })
+
+      return Service.of({ register, ids, tools, deferredIds, toolsByIds })
+    }),
+  )
+
+  export const defaultLayer = Layer.unwrap(
+    Effect.sync(() => layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Plugin.defaultLayer))),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function register(tool: Tool.Info) {
+    return runPromise((svc) => svc.register(tool))
+  }
+
+  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))
+  }
+
+  /** Cache of deferred tool info for ToolSearch */
+  let _deferredToolInfoCache: { id: string; name: string; description: string; searchHints?: string[] }[] = []
+
+  export function setDeferredToolInfoCache(
+    infos: { id: string; name: string; description: string; searchHints?: string[] }[],
+  ) {
+    _deferredToolInfoCache = infos
+  }
+
+  export async function getDeferredToolInfos() {
+    return _deferredToolInfoCache
+  }
+
+  export async function getToolSchemas(
+    ids: string[],
+  ): Promise<{ id: string; description: string; parametersSchema: any }[]> {
+    // We need to init the tools to get their schemas
+    const results: { id: string; description: string; parametersSchema: any }[] = []
+
+    // Access all tools from the default layer and find matching ones
+    const allIds = await ToolRegistry.ids()
+    const matchingIds = ids.filter((id) => allIds.includes(id))
+
+    for (const toolId of matchingIds) {
+      // Find the cached info for the description
+      const cached = _deferredToolInfoCache.find((t) => t.id === toolId)
+      if (cached) {
+        results.push({
+          id: toolId,
+          description: cached.description,
+          parametersSchema: { type: "object", description: "Use toolsByIds to get full schema" },
+        })
+      }
+    }
+
+    return results
+  }
+}

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/sendmessage.ts

@@ -0,0 +1,57 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./sendmessage.txt"
+import z from "zod"
+import { AgentMailbox } from "../agent/mailbox"
+
+export const SendMessageTool = Tool.define("sendmessage", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    to: z.string().describe("Target agent name or '*' for broadcast"),
+    message: z.string().describe("Message content to send"),
+    summary: z.string().optional().describe("5-10 word summary of the message"),
+    correlationID: z.string().optional().describe("Correlation ID for request/response patterns"),
+    expectReply: z.boolean().optional().default(false).describe("Whether to wait for a reply"),
+  }),
+  // @ts-expect-error — return type union metadata mismatch with tool definition
+  async execute(params: { to: string; message: string; summary?: string; correlationID?: string; expectReply?: boolean }, ctx: any) {
+    const from = ctx.agent
+
+    if (params.to === "*") {
+      const count = AgentMailbox.broadcast(from, params.message, params.correlationID)
+      return {
+        title: `Broadcast to ${count} agent(s)`,
+        metadata: { from, to: "*", count },
+        output: `Message broadcast to ${count} active agent(s).`,
+      }
+    }
+
+    AgentMailbox.send({
+      from,
+      to: params.to,
+      message: params.message,
+      correlationID: params.correlationID,
+    })
+
+    if (params.expectReply) {
+      const reply = await AgentMailbox.waitForReply(params.to, from, params.correlationID, 30000)
+      if (reply) {
+        return {
+          title: `Reply from ${params.to}`,
+          metadata: { from, to: params.to, hasReply: true },
+          output: reply.message,
+        }
+      }
+      return {
+        title: `No reply from ${params.to}`,
+        metadata: { from, to: params.to, hasReply: false },
+        output: `Message sent to ${params.to} but no reply received within timeout.`,
+      }
+    }
+
+    return {
+      title: `Sent to ${params.to}`,
+      metadata: { from, to: params.to },
+      output: `Message sent to agent "${params.to}".`,
+    }
+  },
+})

package/src/tool/sendmessage.txt

@@ -0,0 +1,6 @@
+Send a message to another agent or teammate. Use this for inter-agent communication.
+
+- Set "to" to a specific agent name to send directly
+- Set "to" to "*" to broadcast to all active agents
+- Use correlationID for request/response patterns
+- Use expectReply to wait for a response before continuing

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-create.ts

@@ -0,0 +1,25 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task-create.txt"
+import z from "zod"
+import { Task } from "../task"
+
+export const TaskCreateTool = Tool.define("task_create", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    subject: z.string().describe("A brief title for the task"),
+    description: z.string().describe("What needs to be done"),
+    activeForm: z.string().optional().describe("Present continuous form shown in spinner when in_progress"),
+  }),
+  async execute(params, ctx) {
+    const task = Task.create({
+      sessionID: ctx.sessionID as string,
+      description: params.description,
+      agentType: ctx.agent,
+    })
+    return {
+      title: `Created task #${task.id}`,
+      metadata: { taskId: task.id },
+      output: `Task ${task.id} created: ${params.subject}\nStatus: ${task.status}\nDescription: ${params.description}`,
+    }
+  },
+})

package/src/tool/task-create.txt

@@ -0,0 +1 @@
+Create a new task to track work progress. Tasks have statuses (pending, in_progress, completed, failed, killed) and can have dependencies via blocks/blockedBy.

package/src/tool/task-get.ts

@@ -0,0 +1,27 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task-get.txt"
+import z from "zod"
+import { Task } from "../task"
+
+export const TaskGetTool = Tool.define("task_get", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    taskId: z.string().describe("The ID of the task to retrieve"),
+  }),
+  // @ts-expect-error — return type union metadata mismatch with tool definition
+  async execute(params: { taskId: string }, ctx: any) {
+    const task = Task.get(params.taskId)
+    if (!task) {
+      return {
+        title: "Task not found",
+        metadata: {},
+        output: `No task found with ID: ${params.taskId}`,
+      }
+    }
+    return {
+      title: `Task ${task.id}: ${task.status}`,
+      metadata: { task },
+      output: JSON.stringify(task, null, 2),
+    }
+  },
+})

package/src/tool/task-get.txt

@@ -0,0 +1 @@
+Get details of a specific task by its ID.

package/src/tool/task-list.ts

@@ -0,0 +1,45 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task-list.txt"
+import z from "zod"
+import { Task } from "../task"
+
+export const TaskListTool = Tool.define("task_list", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    status: z
+      .enum(["pending", "in_progress", "completed", "failed", "killed"])
+      .optional()
+      .describe("Filter by status"),
+  }),
+  async execute(params, ctx) {
+    let tasks = Task.list(ctx.sessionID as string)
+    if (params.status) {
+      tasks = tasks.filter((t) => t.status === params.status)
+    }
+    if (tasks.length === 0) {
+      return {
+        title: "No tasks",
+        metadata: { count: 0 },
+        output: "No tasks found.",
+      }
+    }
+    const lines = tasks.map((t) => {
+      const icon =
+        t.status === "completed"
+          ? "[completed]"
+          : t.status === "in_progress"
+            ? "[in_progress]"
+            : t.status === "failed"
+              ? "[failed]"
+              : t.status === "killed"
+                ? "[killed]"
+                : "[pending]"
+      return `${icon} #${t.id} ${t.description}`
+    })
+    return {
+      title: `${tasks.length} task(s)`,
+      metadata: { count: tasks.length },
+      output: lines.join("\n"),
+    }
+  },
+})

package/src/tool/task-list.txt

@@ -0,0 +1 @@
+List all tasks in the current session, optionally filtered by status.

package/src/tool/task-output.ts

@@ -0,0 +1,28 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task-output.txt"
+import z from "zod"
+import { Task } from "../task"
+
+export const TaskOutputTool = Tool.define("task_output", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    taskId: z.string().describe("The ID of the task to get output from"),
+  }),
+  // @ts-expect-error — return type union metadata mismatch with tool definition
+  async execute(params: { taskId: string }, ctx: any) {
+    const task = Task.get(params.taskId)
+    if (!task) {
+      return {
+        title: "Task not found",
+        metadata: {},
+        output: `No task found with ID: ${params.taskId}`,
+      }
+    }
+    const output = task.result ?? task.error ?? `Task ${task.id} has no output yet. Status: ${task.status}`
+    return {
+      title: `Output for task #${task.id}`,
+      metadata: { status: task.status },
+      output,
+    }
+  },
+})

package/src/tool/task-output.txt

@@ -0,0 +1 @@
+Get the full output/result from a task. For tasks that spawned subagents, returns the subagent's response.