@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-c13f7gjw.js

@@ -0,0 +1,326 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./repository-2a5m3afh.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  Service14
+} from "./repository-58e8mpmb.js";
+import {
+  Service22,
+  readText2,
+  syncTextBom2
+} from "./repository-h0gkjmvb.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19,
+  resolvePath2
+} from "./repository-pvp1cs2e.js";
+import {
+  fileDiff2
+} from "./repository-6prwharc.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  Applied: () => Applied2,
+  Input: () => Input12,
+  Output: () => Output8,
+  PatchTool: () => exports_patch,
+  Plugin: () => Plugin30,
+  name: () => name12,
+  toModelContent: () => toModelContent6
+});
+import { ToolFailure } from "@opencode/ai";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Effect, Result, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+import { Patch } from "@opencode/util/patch";
+
+// src/tool/patch.txt
+var patch_default = `Use the \`patch\` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+
+// src/tool/plugin/patch.ts
+var name12 = "patch";
+var Input12 = Schema.Struct({
+  patchText: Schema.String.annotate({
+    description: "The full patch text describing add, update, and delete operations"
+  })
+});
+var Applied2 = Schema.Struct({
+  type: Schema.Literals(["add", "update", "delete"]),
+  resource: Schema.String,
+  target: Schema.String
+});
+var Output8 = Schema.Struct({
+  applied: Schema.Array(Applied2),
+  files: Schema.Array(FileDiff.Info)
+});
+var toModelContent6 = (output) => [
+  "Success. Updated the following files:",
+  ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
+].join(`
+`);
+var Plugin30 = {
+  id: "opencode.tool.patch",
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
+    const environment = yield* Service65;
+    const access = yield* Service19;
+    const fileMutation = yield* Service22;
+    const formatter = yield* Service14;
+    const location = yield* Service66;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name12,
+      options: { codemode: false, permission: "edit" },
+      description: patch_default,
+      input: Input12,
+      output: Output8,
+      execute: (input, context) => {
+        const applied = [];
+        const parsed = Patch.parse(input.patchText);
+        const lockTargets = Result.isSuccess(parsed) ? parsed.success.flatMap((hunk) => [
+          resolvePath2(location.directory, hunk.path),
+          ...hunk.type === "update" && hunk.movePath ? [resolvePath2(location.directory, hunk.movePath)] : []
+        ]) : [];
+        const fail = (operation, error) => {
+          const completed = applied.map((item) => item.resource).join(", ");
+          return new ToolFailure({
+            message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`
+          });
+        };
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (!input.patchText)
+            return yield* new ToolFailure({ message: "patchText is required" });
+          const hunks = yield* Effect.fromResult(parsed).pipe(Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })));
+          if (hunks.length === 0) {
+            return yield* new ToolFailure({ message: "patch rejected: empty patch" });
+          }
+          const prepared = [];
+          const updates = new Map;
+          const resolveTarget = Effect.fnUntraced(function* (value) {
+            const target = yield* access.resolve({ path: value, kind: "file" });
+            if (!target.externalDirectory)
+              return target;
+            yield* access.authorizeExternal([target], context, {
+              filepath: target.absolute,
+              parentDir: target.externalDirectory.directory
+            });
+            return target;
+          });
+          for (const hunk of hunks) {
+            yield* Effect.gen(function* () {
+              const target = yield* resolveTarget(hunk.path);
+              if (hunk.type === "add") {
+                const content = hunk.contents.endsWith(`
+`) || hunk.contents === "" ? hunk.contents : `${hunk.contents}
+`;
+                prepared.push({
+                  ...hunk,
+                  target,
+                  content,
+                  before: "",
+                  after: Bom.split(content).text
+                });
+                return;
+              }
+              if (hunk.type === "delete") {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`
+                })));
+                prepared.push({ ...hunk, target, before: content.text, after: "" });
+                return;
+              }
+              const previous = updates.get(target.absolute);
+              const original = previous ?? (yield* Effect.gen(function* () {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`
+                })));
+                return Bom.join(content.text, content.bom);
+              }));
+              const before = Bom.split(original).text;
+              const update = yield* Effect.try({
+                try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` })
+              });
+              const moveTarget = hunk.movePath ? yield* resolveTarget(hunk.movePath) : undefined;
+              prepared.push({
+                ...hunk,
+                target,
+                content: Patch.joinBom(update.content, update.bom),
+                before,
+                after: update.content,
+                moveTarget
+              });
+              if (!moveTarget)
+                updates.set(target.absolute, Patch.joinBom(update.content, update.bom));
+            }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error })));
+          }
+          const patchFiles = prepared.map((change) => patchFile(change));
+          const targets = prepared.flatMap((change) => [
+            change.target,
+            ...change.type === "update" && change.moveTarget ? [change.moveTarget] : []
+          ]);
+          yield* permission.assert({
+            action: "edit",
+            resources: [...new Set(targets.map((target) => target.resource))],
+            save: ["*"],
+            metadata: {
+              filepath: targets.map((target) => target.resource).join(", "),
+              diff: patchFiles.map((file) => `${file.patch}
+`).join(""),
+              files: patchFiles
+            },
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          yield* Effect.forEach(prepared, (change) => Effect.gen(function* () {
+            if (change.type === "delete") {
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.type === "update" && change.moveTarget) {
+              const moveTarget = change.moveTarget;
+              yield* environment.files.write(moveTarget.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)));
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.moveTarget.resource,
+                target: change.moveTarget.absolute
+              });
+              return;
+            }
+            yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+            applied.push({
+              type: change.type,
+              resource: change.target.resource,
+              target: change.target.absolute
+            });
+          }), { discard: true });
+          const formatted = new Map;
+          yield* Effect.forEach([...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))], (target) => Effect.gen(function* () {
+            const current = yield* readText2(environment.files, target).pipe(Effect.mapError((error) => fail(`Failed to read ${target}`, error)));
+            formatted.set(target, (yield* formatter.file(target)) ? yield* syncTextBom2(environment.files, target, current.bom).pipe(Effect.mapError((error) => fail(`Failed to sync ${target}`, error))) : current.text);
+          }), { discard: true });
+          const files = prepared.map((change) => {
+            if (change.type === "delete")
+              return patchFile(change);
+            const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target;
+            return patchFile(change, formatted.get(target.absolute));
+          });
+          return { applied, files };
+        }).pipe(fileMutation.withLock(lockTargets), Effect.map((output) => ({
+          output,
+          content: toModelContent6(output),
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
+      }
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const usePatch = event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4");
+      if (usePatch) {
+        delete event.tools.edit;
+        delete event.tools.write;
+        return;
+      }
+      delete event.tools.patch;
+    }));
+  })
+};
+function errorMessage(error) {
+  if (error instanceof NotFound2)
+    return "file does not exist";
+  if (error instanceof WrongKind2)
+    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`;
+  if (error instanceof Failed2)
+    return errorMessage(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function patchFile(change, after = change.after) {
+  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource;
+  const diff = fileDiff2(change.target.absolute, change.before, after, change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified");
+  return {
+    ...diff,
+    file: target,
+    patch: trimDiff(diff.patch)
+  };
+}
+function trimDiff(diff) {
+  const lines = diff.split(`
+`);
+  const content = lines.filter((line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++"));
+  if (content.length === 0)
+    return diff;
+  const indent = content.reduce((result, line) => {
+    const value = line.slice(1);
+    if (value.trim().length === 0)
+      return result;
+    return Math.min(result, value.match(/^(\s*)/)?.[1].length ?? result);
+  }, Infinity);
+  if (indent === Infinity || indent === 0)
+    return diff;
+  return lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      return line[0] + line.slice(1 + indent);
+    }
+    return line;
+  }).join(`
+`);
+}
+
+export { name12, Input12, Applied2, Output8, toModelContent6, Plugin30, exports_patch };

package/dist/chunks/repository-c968x2fe.js

@@ -0,0 +1,35 @@
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  ConfigWebSearchPlugin: () => exports_websearch,
+  Plugin: () => Plugin14
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin14 = define({
+  id: "opencode.config.websearch",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const loaded = yield* observe2(config, ctx.event, ctx.websearch.reload());
+    yield* ctx.websearch.transform((websearch) => {
+      const selection = latest2(loaded.entries, "websearch");
+      if (selection === false)
+        websearch.default.set(false);
+      if (selection)
+        websearch.default.set(selection.provider);
+    });
+  })
+});
+
+export { Plugin14, exports_websearch };