@vikasitai/vikasit-code 2.0.7 → 2.0.8

package/src/tool/registry.ts

@@ -1,333 +0,0 @@
-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 "@vikasitai/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

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

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

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

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

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

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

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

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

package/src/tool/task-list.ts

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

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

package/src/tool/task-output.ts

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

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