soraacode 0.2.0 → 0.2.2

package/src/tool/apply_patch.ts

@@ -1,313 +0,0 @@
-import * as path from "path"
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { Watcher } from "@soraacode/core/filesystem/watcher"
-import { InstanceState } from "@/effect/instance-state"
-import { Patch } from "../patch"
-import { createTwoFilesPatch, diffLines } from "diff"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import { trimDiff } from "./edit"
-import { LSP } from "@/lsp/lsp"
-import { FSUtil } from "@soraacode/core/fs-util"
-import DESCRIPTION from "./apply_patch.txt"
-import { FileSystem } from "@soraacode/core/filesystem"
-import { Format } from "../format"
-import * as Bom from "@/util/bom"
-
-export const Parameters = Schema.Struct({
-  patchText: Schema.String.annotate({ description: "The full patch text that describes all changes to be made" }),
-})
-
-export const ApplyPatchTool = Tool.define(
-  "apply_patch",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const afs = yield* FSUtil.Service
-    const format = yield* Format.Service
-    const events = yield* EventV2Bridge.Service
-
-    const run = Effect.fn("ApplyPatchTool.execute")(function* (
-      params: Schema.Schema.Type<typeof Parameters>,
-      ctx: Tool.Context,
-    ) {
-      if (!params.patchText) {
-        return yield* Effect.fail(new Error("patchText is required"))
-      }
-
-      // Parse the patch to get hunks
-      let hunks: Patch.Hunk[]
-      try {
-        const parseResult = Patch.parsePatch(params.patchText)
-        hunks = parseResult.hunks
-      } catch (error) {
-        return yield* Effect.fail(new Error(`apply_patch verification failed: ${error}`))
-      }
-
-      if (hunks.length === 0) {
-        const normalized = params.patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim()
-        if (normalized === "*** Begin Patch\n*** End Patch") {
-          return yield* Effect.fail(new Error("patch rejected: empty patch"))
-        }
-        return yield* Effect.fail(new Error("apply_patch verification failed: no hunks found"))
-      }
-
-      const instance = yield* InstanceState.context
-
-      // Validate file paths and check permissions
-      const fileChanges: Array<{
-        filePath: string
-        oldContent: string
-        newContent: string
-        type: "add" | "update" | "delete" | "move"
-        movePath?: string
-        diff: string
-        additions: number
-        deletions: number
-        bom: boolean
-      }> = []
-
-      let totalDiff = ""
-
-      for (const hunk of hunks) {
-        const filePath = path.resolve(instance.directory, hunk.path)
-        yield* assertExternalDirectoryEffect(ctx, filePath)
-
-        switch (hunk.type) {
-          case "add": {
-            const oldContent = ""
-            const newContent =
-              hunk.contents.length === 0 || hunk.contents.endsWith("\n") ? hunk.contents : `${hunk.contents}\n`
-            const next = Bom.split(newContent)
-            const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, next.text))
-
-            let additions = 0
-            let deletions = 0
-            for (const change of diffLines(oldContent, next.text)) {
-              if (change.added) additions += change.count || 0
-              if (change.removed) deletions += change.count || 0
-            }
-
-            fileChanges.push({
-              filePath,
-              oldContent,
-              newContent: next.text,
-              type: "add",
-              diff,
-              additions,
-              deletions,
-              bom: next.bom,
-            })
-
-            totalDiff += diff + "\n"
-            break
-          }
-
-          case "update": {
-            // Check if file exists for update
-            const stats = yield* afs.stat(filePath).pipe(Effect.catch(() => Effect.succeed(undefined)))
-            if (!stats || stats.type === "Directory") {
-              return yield* Effect.fail(
-                new Error(`apply_patch verification failed: Failed to read file to update: ${filePath}`),
-              )
-            }
-
-            const source = yield* Bom.readFile(afs, filePath)
-            const oldContent = source.text
-            let newContent = oldContent
-            let bom = source.bom
-
-            // Apply the update chunks to get new content
-            try {
-              const fileUpdate = Patch.deriveNewContentsFromChunks(
-                filePath,
-                hunk.chunks,
-                Bom.join(source.text, source.bom),
-              )
-              newContent = fileUpdate.content
-              bom = fileUpdate.bom
-            } catch (error) {
-              return yield* Effect.fail(new Error(`apply_patch verification failed: ${error}`))
-            }
-
-            const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
-
-            let additions = 0
-            let deletions = 0
-            for (const change of diffLines(oldContent, newContent)) {
-              if (change.added) additions += change.count || 0
-              if (change.removed) deletions += change.count || 0
-            }
-
-            const movePath = hunk.move_path ? path.resolve(instance.directory, hunk.move_path) : undefined
-            yield* assertExternalDirectoryEffect(ctx, movePath)
-
-            fileChanges.push({
-              filePath,
-              oldContent,
-              newContent,
-              type: hunk.move_path ? "move" : "update",
-              movePath,
-              diff,
-              additions,
-              deletions,
-              bom,
-            })
-
-            totalDiff += diff + "\n"
-            break
-          }
-
-          case "delete": {
-            const source = yield* Bom.readFile(afs, filePath).pipe(
-              Effect.catch((error) =>
-                Effect.fail(
-                  new Error(
-                    `apply_patch verification failed: ${error instanceof Error ? error.message : String(error)}`,
-                  ),
-                ),
-              ),
-            )
-            const contentToDelete = source.text
-            const deleteDiff = trimDiff(createTwoFilesPatch(filePath, filePath, contentToDelete, ""))
-
-            const deletions = contentToDelete.split("\n").length
-
-            fileChanges.push({
-              filePath,
-              oldContent: contentToDelete,
-              newContent: "",
-              type: "delete",
-              diff: deleteDiff,
-              additions: 0,
-              deletions,
-              bom: source.bom,
-            })
-
-            totalDiff += deleteDiff + "\n"
-            break
-          }
-        }
-      }
-
-      // Build per-file metadata for UI rendering (used for both permission and result)
-      const files = fileChanges.map((change) => ({
-        filePath: change.filePath,
-        relativePath: path.relative(instance.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
-        type: change.type,
-        patch: change.diff,
-        additions: change.additions,
-        deletions: change.deletions,
-        ...(change.movePath ? { movePath: change.movePath } : {}),
-      }))
-
-      // Check permissions if needed
-      const relativePaths = fileChanges.map((c) => path.relative(instance.worktree, c.filePath).replaceAll("\\", "/"))
-      yield* ctx.ask({
-        permission: "edit",
-        patterns: relativePaths,
-        always: ["*"],
-        metadata: {
-          filepath: relativePaths.join(", "),
-          diff: totalDiff,
-          files,
-        },
-      })
-
-      // Apply the changes
-      const updates: Array<{ file: string; event: "add" | "change" | "unlink" }> = []
-
-      for (const change of fileChanges) {
-        const edited = change.type === "delete" ? undefined : (change.movePath ?? change.filePath)
-        switch (change.type) {
-          case "add":
-            // Create parent directories (recursive: true is safe on existing/root dirs)
-
-            yield* afs.writeWithDirs(change.filePath, Bom.join(change.newContent, change.bom))
-            updates.push({ file: change.filePath, event: "add" })
-            break
-
-          case "update":
-            yield* afs.writeWithDirs(change.filePath, Bom.join(change.newContent, change.bom))
-            updates.push({ file: change.filePath, event: "change" })
-            break
-
-          case "move":
-            if (change.movePath) {
-              // Create parent directories (recursive: true is safe on existing/root dirs)
-
-              yield* afs.writeWithDirs(change.movePath!, Bom.join(change.newContent, change.bom))
-              yield* afs.remove(change.filePath)
-              updates.push({ file: change.filePath, event: "unlink" })
-              updates.push({ file: change.movePath, event: "add" })
-            }
-            break
-
-          case "delete":
-            yield* afs.remove(change.filePath)
-            updates.push({ file: change.filePath, event: "unlink" })
-            break
-        }
-
-        if (edited) {
-          if (yield* format.file(edited)) {
-            yield* Bom.syncFile(afs, edited, change.bom)
-          }
-          yield* events.publish(FileSystem.Event.Edited, { file: edited })
-        }
-      }
-
-      // Publish file change events
-      for (const update of updates) {
-        yield* events.publish(Watcher.Event.Updated, update)
-      }
-
-      // Notify LSP of file changes and collect diagnostics
-      for (const change of fileChanges) {
-        if (change.type === "delete") continue
-        const target = change.movePath ?? change.filePath
-        yield* lsp.touchFile(target, "document")
-      }
-      const diagnostics = yield* lsp.diagnostics()
-
-      // Generate output summary
-      const summaryLines = fileChanges.map((change) => {
-        if (change.type === "add") {
-          return `A ${path.relative(instance.worktree, change.filePath).replaceAll("\\", "/")}`
-        }
-        if (change.type === "delete") {
-          return `D ${path.relative(instance.worktree, change.filePath).replaceAll("\\", "/")}`
-        }
-        const target = change.movePath ?? change.filePath
-        return `M ${path.relative(instance.worktree, target).replaceAll("\\", "/")}`
-      })
-      let output = `Success. Updated the following files:\n${summaryLines.join("\n")}`
-
-      for (const change of fileChanges) {
-        if (change.type === "delete") continue
-        const target = change.movePath ?? change.filePath
-        const block = LSP.Diagnostic.report(target, diagnostics[FSUtil.normalizePath(target)] ?? [])
-        if (!block) continue
-        const rel = path.relative(instance.worktree, target).replaceAll("\\", "/")
-        output += `\n\nLSP errors detected in ${rel}, please fix:\n${block}`
-      }
-
-      return {
-        title: output,
-        metadata: {
-          diff: totalDiff,
-          files,
-          diagnostics,
-        },
-        output,
-      }
-    })
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        run(params, ctx).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/apply_patch.txt

@@ -1,14 +0,0 @@
-Use stripped-down diff format:
-
-*** Begin Patch
-*** Add File: <path>
-+content
-*** Delete File: <path>
-*** Update File: <path>
-*** Move to: <new-path>
-@@
--old
-+new
-*** End Patch
-
-Each operation requires a header. New lines require +.

package/src/tool/code-mode.ts

@@ -1,310 +0,0 @@
-import * as Tool from "./tool"
-import { CallToolResultSchema, type CallToolResult } from "@modelcontextprotocol/sdk/types.js"
-import { Cause, Effect, Schema } from "effect"
-import { CodeMode, Tool as SandboxTool, toolError } from "@soraacode/codemode"
-import { MCP } from "@/mcp"
-import { McpCatalog } from "@/mcp/catalog"
-import { Agent } from "@/agent/agent"
-import { Session } from "@/session/session"
-import { Permission } from "@/permission"
-import { Plugin } from "@/plugin"
-
-export const CODE_MODE_TOOL = "execute"
-
-const DESCRIPTION = "Run a confined orchestration script with access to connected MCP tools."
-
-export const Parameters = Schema.Struct({
-  code: Schema.String.annotate({
-    description: "Script body executed by the confined interpreter.",
-  }),
-})
-
-type CallEntry = { tool: string; status: "running" | "completed" | "error"; input?: Record<string, unknown> }
-
-type Metadata = {
-  toolCalls: CallEntry[]
-  error?: boolean
-}
-
-type Attachment = NonNullable<Tool.ExecuteResult["attachments"]>[number]
-
-type CatalogEntry = {
-  path: string
-  key: string
-  server: string
-  local: string
-  tool: MCP.McpTool
-}
-
-function groupByServer(mcpTools: Record<string, MCP.McpTool>, servers: readonly string[]): Map<string, CatalogEntry[]> {
-  const byLongest = [...servers].sort((a, b) => b.length - a.length)
-  const groups = new Map<string, CatalogEntry[]>()
-  for (const key of Object.keys(mcpTools).sort((a, b) => a.localeCompare(b))) {
-    const server =
-      byLongest.find((name) => key.startsWith(name + "_")) ?? (key.includes("_") ? key.slice(0, key.indexOf("_")) : key)
-    const local = server && key.startsWith(server + "_") ? key.slice(server.length + 1) : key
-    const entry: CatalogEntry = {
-      path: `${server}.${local}`,
-      key,
-      server,
-      local,
-      tool: mcpTools[key]!,
-    }
-    groups.set(server, [...(groups.get(server) ?? []), entry])
-  }
-  return groups
-}
-
-export function describeCatalog(mcpTools: Record<string, MCP.McpTool>, servers: readonly string[]): string {
-  return CodeMode.make({
-    tools: toolTree(
-      [...groupByServer(mcpTools, servers).values()].flat(),
-      () => () => Effect.fail(toolError("Tool preview is not executable.")),
-    ),
-  }).instructions()
-}
-
-const lastSegment = (uri: string) => {
-  const trimmed = uri.split(/[?#]/, 1)[0]!.replace(/\/+$/, "")
-  const segment = trimmed.slice(trimmed.lastIndexOf("/") + 1)
-  return segment.length > 0 ? segment : undefined
-}
-
-const dataUrl = (mime: string, base64: string) => `data:${mime};base64,${base64}`
-
-function projectMcpResult(result: CallToolResult, collect: (attachment: Attachment) => void): unknown {
-  const text: string[] = []
-  let files = 0
-  let images = 0
-  const push = (attachment: Attachment) => {
-    files += 1
-    if (attachment.mime.startsWith("image/")) images += 1
-    collect(attachment)
-  }
-  for (const block of result.content) {
-    switch (block.type) {
-      case "text":
-        text.push(block.text)
-        break
-      case "image":
-      case "audio":
-        push({ type: "file", mime: block.mimeType, url: dataUrl(block.mimeType, block.data) })
-        break
-      case "resource": {
-        if ("text" in block.resource) {
-          text.push(block.resource.text)
-          break
-        }
-        const mime = block.resource.mimeType ?? "application/octet-stream"
-        push({ type: "file", mime, url: dataUrl(mime, block.resource.blob), filename: lastSegment(block.resource.uri) })
-        break
-      }
-      case "resource_link":
-        // A link is a reference, not fetchable media; hand it to the program instead of the attachment channel.
-        text.push(`${block.name}: ${block.uri}`)
-        break
-    }
-  }
-
-  if (result.structuredContent !== undefined && result.structuredContent !== null) return result.structuredContent
-  if (text.length > 0) return text.join("\n")
-  if (files > 0) {
-    const noun = files === images ? "image" : "file"
-    return `[${files} ${noun}${files === 1 ? "" : "s"} attached to the result]`
-  }
-  return null
-}
-
-type Run = (input: unknown) => Effect.Effect<unknown, unknown>
-
-function toolTree(catalog: readonly CatalogEntry[], run: (entry: CatalogEntry) => Run) {
-  const tree: Record<string, Record<string, SandboxTool.Definition>> = {}
-  for (const entry of catalog) {
-    const namespace = (tree[entry.server] ??= {})
-    namespace[entry.local] = SandboxTool.make({
-      description: entry.tool.def.description ?? "",
-      input: entry.tool.def.inputSchema as SandboxTool.JsonSchema,
-      output: entry.tool.def.outputSchema as SandboxTool.JsonSchema | undefined,
-      run: run(entry),
-    })
-  }
-  return tree
-}
-
-const invokeChildTool = Effect.fn("CodeMode.invokeChildTool")(function* (input: {
-  plugin: Plugin.Interface
-  entry: CatalogEntry
-  args: Record<string, unknown>
-  callID: string
-  ctx: Tool.Context
-}) {
-  yield* input.plugin.trigger(
-    "tool.execute.before",
-    { tool: input.entry.key, sessionID: input.ctx.sessionID, callID: input.callID },
-    { args: input.args },
-  )
-  const result: CallToolResult = yield* Effect.gen(function* () {
-    yield* input.ctx.ask({ permission: input.entry.key, metadata: {}, patterns: ["*"], always: ["*"] })
-    // Deliberately mirrors McpCatalog.convertTool's transport call so the MCP service stays free of tool-loop concerns.
-    return yield* Effect.promise(async () => {
-      const raw = await input.entry.tool.client.callTool(
-        { name: input.entry.tool.def.name, arguments: input.args },
-        CallToolResultSchema,
-        {
-          resetTimeoutOnProgress: true,
-          signal: input.ctx.abort,
-          timeout: input.entry.tool.timeout,
-          // The MCP SDK only sends a progress token when this hook is present, enabling timeout resets.
-          onprogress: () => {},
-        },
-      )
-      if (raw.isError)
-        throw new Error(
-          raw.content
-            .flatMap((item) => (item.type === "text" ? [item.text] : []))
-            .filter((text) => text.trim())
-            .join("\n\n") || "MCP tool returned an error",
-        )
-      return raw
-    })
-  }).pipe(
-    Effect.withSpan("Tool.execute", {
-      attributes: {
-        "tool.name": input.entry.key,
-        "tool.call_id": input.callID,
-        "session.id": input.ctx.sessionID,
-        "message.id": input.ctx.messageID,
-      },
-    }),
-  )
-  yield* input.plugin.trigger(
-    "tool.execute.after",
-    { tool: input.entry.key, sessionID: input.ctx.sessionID, callID: input.callID, args: input.args },
-    result,
-  )
-  return result
-})
-
-export const CodeModeTool = Tool.define(
-  CODE_MODE_TOOL,
-  Effect.gen(function* () {
-    const mcp = yield* MCP.Service
-    const agents = yield* Agent.Service
-    const sessions = yield* Session.Service
-    const plugin = yield* Plugin.Service
-
-    const init: Tool.DefWithoutID<typeof Parameters, Metadata> = {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: Effect.fn("CodeMode.execute")(function* (params, ctx) {
-        if (ctx.abort.aborted) {
-          return {
-            title: CODE_MODE_TOOL,
-            metadata: { toolCalls: [], error: true },
-            output: "Execution cancelled.",
-          } satisfies Tool.ExecuteResult<Metadata>
-        }
-        const agent = yield* agents.get(ctx.agent)
-        const session = yield* sessions.get(ctx.sessionID).pipe(Effect.orDie)
-        const ruleset = Permission.merge(agent.permission, session.permission ?? [])
-        const mcpTools = Permission.visibleTools(yield* mcp.tools(), ruleset)
-        const servers = Object.keys(yield* mcp.clients()).map(McpCatalog.sanitize)
-        const catalog = [...groupByServer(mcpTools, servers).values()].flat()
-
-        const calls: CallEntry[] = []
-        const attachments: Attachment[] = []
-        const publish = () =>
-          ctx.metadata({ title: CODE_MODE_TOOL, metadata: { toolCalls: calls.map((c) => ({ ...c })) } })
-
-        let childCalls = 0
-        const callTool = (entry: CatalogEntry) => (input: unknown) =>
-          Effect.gen(function* () {
-            childCalls += 1
-            const result = yield* invokeChildTool({
-              plugin,
-              entry,
-              args: (input ?? {}) as Record<string, unknown>,
-              callID: `${ctx.callID ?? entry.key}/${childCalls}`,
-              ctx,
-            })
-            return projectMcpResult(result, (attachment: Attachment) => void attachments.push(attachment))
-          }).pipe(
-            Effect.catchCause((cause) => {
-              if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt
-              const error = Cause.squash(cause)
-              return Effect.fail(toolError(error instanceof Error ? error.message : String(error), error))
-            }),
-          )
-
-        const runtime = CodeMode.make({
-          tools: toolTree(catalog, callTool),
-          onToolCallStart: ({ index, name, input }) =>
-            Effect.suspend(() => {
-              const shown = (() => {
-                if (input === null || input === undefined) return
-                if (typeof input === "object" && !Array.isArray(input)) {
-                  const value = input as Record<string, unknown>
-                  return Object.keys(value).length > 0 ? value : undefined
-                }
-                return { input }
-              })()
-              calls[index] = { tool: name, status: "running", ...(shown ? { input: shown } : {}) }
-              return publish()
-            }),
-          onToolCallEnd: ({ index, outcome }) =>
-            Effect.suspend(() => {
-              const current = calls[index]
-              if (current) calls[index] = { ...current, status: outcome === "success" ? "completed" : "error" }
-              return publish()
-            }),
-        })
-
-        const abort = Effect.callback<void>((resume) => {
-          if (ctx.abort.aborted) return resume(Effect.void)
-          const handler = () => resume(Effect.void)
-          ctx.abort.addEventListener("abort", handler, { once: true })
-          return Effect.sync(() => ctx.abort.removeEventListener("abort", handler))
-        })
-        const cancelled = (): CodeMode.Result => ({
-          ok: false,
-          error: { kind: "ExecutionFailure", message: "Execution cancelled." },
-          toolCalls: calls.map((call) => ({ name: call.tool })),
-        })
-
-        const result = yield* Effect.raceFirst(runtime.execute(params.code), abort.pipe(Effect.map(cancelled)))
-        const logs = result.logs ?? []
-        const withLogs = (text: string) => {
-          if (logs.length === 0) return text
-          return text.length > 0 ? `${text}\n\nLogs:\n${logs.join("\n")}` : `Logs:\n${logs.join("\n")}`
-        }
-
-        if (!result.ok) {
-          if (ctx.abort.aborted) {
-            return {
-              title: CODE_MODE_TOOL,
-              metadata: { toolCalls: calls, error: true },
-              output: "Execution cancelled.",
-            } satisfies Tool.ExecuteResult<Metadata>
-          }
-          const hints = (result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))
-          return yield* Effect.fail(new Error(withLogs([result.error.message, ...hints].join("\n"))))
-        }
-
-        // The interpreter validates returned values as plain JSON, so stringify cannot throw;
-        // it yields undefined only for a program that returns undefined.
-        const output =
-          typeof result.value === "string"
-            ? result.value
-            : (JSON.stringify(result.value, null, 2) ?? String(result.value))
-
-        return {
-          title: CODE_MODE_TOOL,
-          metadata: { toolCalls: calls },
-          output: withLogs(output),
-          ...(attachments.length > 0 ? { attachments } : {}),
-        } satisfies Tool.ExecuteResult<Metadata>
-      }, Effect.orDie),
-    }
-    return init
-  }),
-)