@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-v9bfv94f.js

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Rule: () => Rule,
+  Object: () => Object,
+  Info: () => Info,
+  ConfigPermissionV1: () => exports_permission,
+  Action: () => Action
+});
+import { Schema, SchemaGetter } from "effect";
+var Action = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object = Schema.Record(Schema.String, Action).annotate({ identifier: "PermissionObjectConfig" });
+var Rule = Schema.Union([Action, Object]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule),
+  edit: Schema.optional(Rule),
+  glob: Schema.optional(Rule),
+  grep: Schema.optional(Rule),
+  list: Schema.optional(Rule),
+  bash: Schema.optional(Rule),
+  task: Schema.optional(Rule),
+  external_directory: Schema.optional(Rule),
+  question: Schema.optional(Action),
+  webfetch: Schema.optional(Action),
+  websearch: Schema.optional(Action),
+  lsp: Schema.optional(Rule),
+  doom_loop: Schema.optional(Action),
+  skill: Schema.optional(Rule)
+}), [Schema.Record(Schema.String, Rule)]);
+var InputSchema = Schema.Union([Action, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action, Object, Rule, Info, exports_permission };

package/dist/chunks/ripgrep-vee0pxvg.js

@@ -0,0 +1,171 @@
+import {
+  exports_host
+} from "./ripgrep-4vzq6xdm.js";
+import {
+  exports_runtime
+} from "./ripgrep-5rzqpsek.js";
+import {
+  exports_websearch
+} from "./ripgrep-tsmrmbvn.js";
+import {
+  exports_tool
+} from "./ripgrep-dxqw5jns.js";
+import {
+  exports_reference
+} from "./ripgrep-77qdnkw9.js";
+import {
+  exports_hooks
+} from "./ripgrep-0dwyqmzq.js";
+import {
+  exports_command
+} from "./ripgrep-mz3jaqv3.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_skill
+} from "./ripgrep-p5bd5gkc.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  exports_aisdk
+} from "./ripgrep-wqhtb879.js";
+import {
+  exports_catalog
+} from "./ripgrep-1cxcv3mr.js";
+import {
+  exports_integration
+} from "./ripgrep-qrmb8ve0.js";
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  node: () => node,
+  Service: () => Service,
+  Plugin: () => exports_plugin,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event
+});
+import { Event, ID, Info } from "@opencode-ai/schema/plugin";
+import { Plugin } from "@opencode-ai/schema/plugin";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Exit, Layer, Logger, References, Scope, Semaphore } from "effect";
+class Service extends Context.Service()("@opencode/Plugin") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const scope = yield* Scope.make();
+  const active = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  let host;
+  const load = Effect.fnUntraced(function* (plugin) {
+    const child = yield* Scope.fork(scope);
+    const inherit = yield* exports_state.inherit();
+    const loaded = yield* Effect.suspend(() => plugin.effect(host)).pipe(inherit, Effect.updateContext((context) => Context.make(Scope.Scope, child).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.andThen(bus.publish(Plugin.Event.Added, { id: Plugin.ID.make(plugin.id) })), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void), Effect.exit);
+    if (Exit.isSuccess(loaded))
+      return child;
+    yield* Effect.logWarning("failed to load plugin", {
+      "plugin.id": plugin.id,
+      cause: loaded.cause
+    });
+    return;
+  });
+  const activate = Effect.fn("Plugin.activate")(function* (plugins) {
+    const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }));
+    const ids = new Set;
+    for (const definition of definitions) {
+      if (ids.has(definition.id))
+        yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`));
+      ids.add(definition.id);
+    }
+    yield* lock.withPermit(Effect.gen(function* () {
+      const next = definitions.map((definition) => ({ id: definition.id, version: definition.version }));
+      const current = Array.from(active.values(), (entry) => ({
+        id: entry.plugin.id,
+        version: entry.plugin.version
+      }));
+      if (current.length === next.length && current.every((definition, index) => {
+        const candidate = next[index];
+        return definition.id === candidate?.id && definition.version === candidate.version;
+      }))
+        return;
+      yield* exports_state.batch(Effect.gen(function* () {
+        for (const definition of definitions) {
+          const previous = active.get(definition.id);
+          active.delete(definition.id);
+          if (previous)
+            yield* Scope.close(previous.scope, Exit.void).pipe(Effect.ignore);
+          const loaded = yield* load(definition);
+          if (loaded) {
+            active.set(definition.id, { plugin: definition, scope: loaded });
+            continue;
+          }
+          if (!previous)
+            continue;
+          const restored = yield* load(previous.plugin);
+          if (restored) {
+            active.set(definition.id, { plugin: previous.plugin, scope: restored });
+            continue;
+          }
+          yield* Effect.logError("failed to restore plugin; deactivating", {
+            "plugin.id": definition.id
+          });
+        }
+        const removed = Array.from(active.entries()).filter(([id]) => !ids.has(id)).toReversed();
+        removed.forEach(([id]) => active.delete(id));
+        yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void).pipe(Effect.ignore), {
+          discard: true
+        });
+      }));
+      yield* bus.publish(Plugin.Event.Updated, {});
+    }));
+  });
+  yield* Effect.addFinalizer((exit) => Effect.gen(function* () {
+    active.clear();
+    yield* exports_state.batch(Scope.close(scope, exit));
+  }));
+  const service = Service.of({
+    activate,
+    list: Effect.fn("Plugin.list")(function* () {
+      return Array.from(active.keys()).map((id) => ({ id }));
+    })
+  });
+  host = yield* exports_host.make(service);
+  return service;
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    exports_app.node,
+    exports_agent.node,
+    exports_aisdk.node,
+    exports_catalog.node,
+    exports_command.node,
+    exports_integration.node,
+    exports_location.node,
+    exports_reference.node,
+    exports_skill.node,
+    exports_tool.node,
+    exports_hooks.node,
+    exports_runtime.node,
+    exports_websearch.node
+  ]
+});
+
+export { Service, node, exports_plugin, Event, ID, Info };

package/dist/chunks/ripgrep-vp34t77k.js

@@ -0,0 +1,162 @@
+import {
+  exports_model_headers
+} from "./ripgrep-1xksxgzs.js";
+import {
+  exports_model_http
+} from "./ripgrep-93qdgxxd.js";
+import {
+  exports_usage
+} from "./ripgrep-8ywqk2j9.js";
+import {
+  exports_model
+} from "./ripgrep-h90v6ecj.js";
+import {
+  llmClient
+} from "./ripgrep-j1a5h53y.js";
+import {
+  exports_hooks
+} from "./ripgrep-0dwyqmzq.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_store
+} from "./ripgrep-3kbfazvv.js";
+import {
+  exports_history
+} from "./ripgrep-yndnp7z4.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/title.ts
+var exports_title = {};
+__export(exports_title, {
+  node: () => node,
+  layer: () => layer,
+  SessionTitle: () => exports_title,
+  Service: () => Service
+});
+import { LLM, LLMClient, LLMEvent, Message } from "@opencode-ai/ai";
+import { Context, DateTime, Effect, Layer, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { isExactRootFallback } from "@opencode-ai/util/session-title-fallback";
+var MAX_LENGTH = 100;
+var titleChanged = Symbol("Session title changed");
+
+class Service extends Context.Service()("@opencode/SessionTitle") {
+}
+var truncate = (value) => value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`;
+var isUntitled = (session) => isExactRootFallback({
+  title: session.title,
+  time: { created: DateTime.toEpochMillis(session.time.created) }
+});
+var make = (dependencies) => {
+  const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (db, sessionID) {
+    const session = yield* dependencies.store.get(sessionID);
+    if (!session)
+      return;
+    if (session.parentID)
+      return;
+    if (!isUntitled(session))
+      return;
+    const firstUser = yield* exports_history.firstUserMessage(db, session.id);
+    if (!firstUser)
+      return;
+    const agent = yield* dependencies.agents.get(exports_agent.ID.make("title"));
+    if (!agent)
+      return;
+    const resolved = yield* (agent.model ? dependencies.models.resolve({ ...session, model: agent.model }) : dependencies.models.resolve(session)).pipe(Effect.catch(() => Effect.succeed(undefined)));
+    if (!resolved)
+      return;
+    const chunks = [];
+    let failed = false;
+    let usage;
+    const recordUsage = Effect.suspend(() => usage ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
+      sessionID: session.id,
+      source: "title",
+      ...usage
+    }) : Effect.void);
+    const streamed = yield* dependencies.llm.stream(LLM.request({
+      model: resolved.model,
+      http: { headers: exports_model_headers.make(session, dependencies.app) },
+      system: agent.system,
+      messages: [Message.user(firstUser.text)],
+      tools: []
+    }), {
+      http: exports_model_http.middleware(dependencies.hooks, {
+        sessionID: session.id,
+        agent: agent.id,
+        model: resolved.ref
+      })
+    }).pipe(Stream.runForEach((event) => {
+      if (LLMEvent.is.providerError(event))
+        failed = true;
+      if (LLMEvent.is.textDelta(event))
+        chunks.push(event.text);
+      if (LLMEvent.is.stepFinish(event)) {
+        const step = exports_usage.record(event.usage, resolved.cost);
+        usage = usage ? exports_usage.add(usage, step) : step;
+      }
+      return Effect.void;
+    }), Effect.as(true), Effect.catchTag("AI.Error", () => Effect.succeed(false)), Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)));
+    yield* recordUsage;
+    if (!streamed || failed)
+      return;
+    const title = chunks.join("").split(`
+`).map((line) => line.trim()).find((line) => line.length > 0);
+    if (!title)
+      return;
+    const expectedSequence = (yield* exports_bus.latestSequence(db, sessionID)) + 1;
+    const current = yield* dependencies.store.get(sessionID);
+    if (!current || !isUntitled(current))
+      return;
+    yield* dependencies.bus.publish(SessionEvent.Renamed, {
+      sessionID: session.id,
+      title: truncate(title)
+    }, { commit: (sequence) => sequence === expectedSequence ? Effect.void : Effect.die(titleChanged) }).pipe(Effect.catchDefect((defect) => defect === titleChanged ? Effect.void : Effect.die(defect)));
+  });
+  return { generateForFirstPrompt };
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const llm = yield* LLMClient.Service;
+  const agents = yield* exports_agent.Service;
+  const models = yield* exports_model.Service;
+  const store = yield* exports_store.Service;
+  const database = yield* exports_database.Service;
+  const app = yield* exports_app.Metadata;
+  const hooks = yield* exports_hooks.Service;
+  const title = make({ bus, llm, agents, models, store, app, hooks });
+  return Service.of({
+    generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID)
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    llmClient,
+    exports_agent.node,
+    exports_model.node,
+    exports_store.node,
+    exports_database.node,
+    exports_app.node,
+    exports_hooks.node
+  ]
+});
+
+export { Service, layer, node, exports_title };

package/dist/chunks/ripgrep-vp7n0g03.js

@@ -0,0 +1,94 @@
+import {
+  migrations
+} from "./ripgrep-2xr81cqg.js";
+import {
+  schema_gen_default
+} from "./ripgrep-ecxv0vtt.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/database/migration.ts
+var exports_migration = {};
+__export(exports_migration, {
+  applyOnly: () => applyOnly,
+  apply: () => apply,
+  DatabaseMigration: () => exports_migration
+});
+import { sql } from "drizzle-orm";
+import { Effect, Semaphore } from "effect";
+import { supportsForeignKeyToggle } from "#sqlite";
+var lock = Semaphore.makeUnsafe(1);
+function apply(db) {
+  return lock.withPermit(Effect.gen(function* () {
+    const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
+    if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
+      return yield* applyOnly(db, migrations);
+    if (tables.length > 0)
+      return yield* Effect.die(new Error("Database is not empty and has no session table"));
+    const started = Date.now();
+    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations.length });
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* schema_gen_default.up(tx);
+      yield* tx.run(sql`CREATE TABLE ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+      yield* Effect.forEach(migrations, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
+    }));
+    yield* Effect.logInfo("database schema bootstrap completed", {
+      migrations: migrations.length,
+      durationMs: Date.now() - started
+    });
+  }));
+}
+function applyOnly(db, input) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+    let completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+    if (completed.size === 0) {
+      if (yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${"__drizzle_migrations"}`)) {
+        yield* db.run(sql`
+          INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
+          SELECT name, ${Date.now()}
+          FROM ${sql.identifier("__drizzle_migrations")}
+          WHERE name IS NOT NULL
+        `);
+        completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+      }
+    }
+    for (const migration of input) {
+      if (completed.has(migration.id))
+        continue;
+      const started = Date.now();
+      yield* Effect.logInfo("database migration started", { migration: migration.id });
+      const apply2 = db.transaction((tx) => Effect.gen(function* () {
+        yield* migration.up(tx);
+        yield* tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`);
+      }));
+      if (migration.foreignKeys !== false) {
+        yield* apply2.pipe(Effect.tapError((error) => Effect.logError("database migration failed", {
+          migration: migration.id,
+          durationMs: Date.now() - started,
+          error
+        })));
+        yield* Effect.logInfo("database migration completed", {
+          migration: migration.id,
+          durationMs: Date.now() - started
+        });
+        continue;
+      }
+      const relaxForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = OFF`) : db.run(sql`PRAGMA defer_foreign_keys = ON`);
+      const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void;
+      yield* relaxForeignKeys;
+      yield* apply2.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)), Effect.tapError((error) => Effect.logError("database migration failed", {
+        migration: migration.id,
+        durationMs: Date.now() - started,
+        error
+      })));
+      yield* Effect.logInfo("database migration completed", {
+        migration: migration.id,
+        durationMs: Date.now() - started
+      });
+    }
+  });
+}
+
+export { apply, applyOnly, exports_migration };

package/dist/chunks/ripgrep-vs34mv1a.js

@@ -0,0 +1,203 @@
+import {
+  fileDiff
+} from "./ripgrep-c77ad0vh.js";
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_formatter
+} from "./ripgrep-qvqgqyrp.js";
+import {
+  exports_file_mutation
+} from "./ripgrep-s87vpmv3.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  name: () => name,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  EditTool: () => exports_edit
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { Bom } from "@opencode-ai/util/bom";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name = "edit";
+var Input = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "File to edit"
+  }),
+  oldString: Schema.String.annotate({ description: "Exact text to find and replace" }),
+  newString: Schema.String.annotate({ description: "Text to replace oldString with (must differ from oldString)" }),
+  replaceAll: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Whether to replace every occurrence of oldString. When false, oldString must match exactly once. Defaults to false."
+  })
+});
+var Output = Schema.Struct({
+  files: Schema.Array(FileDiff.Info),
+  replacements: Schema.Number
+});
+var crlf = `\r
+`;
+var normalizeForMatch = (value) => value.replace(/[‘’‚‛]/g, "'").replace(/[“”„‟]/g, '"').replace(/[‐‑‒–—―−]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+var findOccurrences = (content, search) => {
+  const result = [];
+  let offset = 0;
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    result.push({ start: offset, end: offset + search.length });
+    offset += search.length;
+  }
+  return result;
+};
+var findLineOccurrences = (content, search) => {
+  const trailingNewline = search.endsWith(`
+`);
+  const expected = search.split(`
+`);
+  if (trailingNewline)
+    expected.pop();
+  const lines = [...content.matchAll(/[^\n]*(?:\n|$)/g)].filter((match) => match[0] !== "").map((match) => {
+    const newline = match[0].endsWith(`
+`);
+    const text = newline ? match[0].slice(0, -1) : match[0];
+    return {
+      start: match.index,
+      end: match.index + match[0].length,
+      text,
+      contentEnd: match.index + text.length - (text.endsWith("\r") ? 1 : 0),
+      newline
+    };
+  });
+  const candidates = lines.flatMap((line, index) => {
+    const actual = lines.slice(index, index + expected.length);
+    if (actual.length !== expected.length)
+      return [];
+    if (!actual.every((item, lineIndex) => normalizeForMatch(item.text.trimEnd()) === normalizeForMatch(expected[lineIndex].trimEnd())))
+      return [];
+    const last = actual.at(-1);
+    if (trailingNewline && !last.newline)
+      return [];
+    return [{ start: line.start, end: trailingNewline ? last.end : last.contentEnd }];
+  });
+  return candidates.reduce((result, candidate) => {
+    if (result.some((match) => match.end > candidate.start && match.start < candidate.end))
+      return result;
+    result.push(candidate);
+    return result;
+  }, []);
+};
+var Plugin = {
+  id: "opencode.tool.edit",
+  effect: Effect.fn("EditTool.Plugin")(function* (ctx) {
+    const mutation = yield* exports_location_mutation.Service;
+    const fileMutation = yield* exports_file_mutation.Service;
+    const environment = yield* exports_environment.Service;
+    const formatter = yield* exports_formatter.Service;
+    const location = yield* exports_location.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.",
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const permissionSource = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (input.oldString === input.newString) {
+            return yield* new ToolFailure({
+              message: "No changes to apply: oldString and newString are identical."
+            });
+          }
+          if (input.oldString === "") {
+            return yield* new ToolFailure({
+              message: "oldString must not be empty. Use write to create or overwrite a file."
+            });
+          }
+          const target = yield* mutation.resolve({ path: input.path, kind: "file" });
+          const external = target.externalDirectory;
+          if (external) {
+            yield* permission.assert({
+              ...exports_location_mutation.externalDirectoryPermission(external),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: permissionSource
+            });
+          }
+          const original = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` }))), Effect.catchTag("Environment.WrongKind", (error) => error.actual === "directory" ? Effect.fail(new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` })) : Effect.fail(new ToolFailure({ message: `Unable to edit ${input.path}`, error }))));
+          const source = original.text;
+          const ending = source.includes(crlf) ? crlf : `
+`;
+          const oldString = input.oldString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const newString = input.newString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const exact = findOccurrences(source, oldString);
+          const unicode = exact.length > 0 ? [] : findOccurrences(normalizeForMatch(source), normalizeForMatch(oldString));
+          const trailing = exact.length > 0 || unicode.length > 0 ? [] : findLineOccurrences(source, oldString);
+          const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing;
+          const replacements = matches.length;
+          const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1)).toReversed().reduce((content, match) => `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`, source);
+          const preview = replacements > 0 && (replacements === 1 || input.replaceAll === true) ? fileDiff(target.resource, source, replaced) : undefined;
+          yield* permission.assert({
+            action: "edit",
+            resources: [target.resource],
+            save: ["*"],
+            metadata: preview ? { files: [preview] } : undefined,
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: permissionSource
+          });
+          if (replacements === 0) {
+            return yield* new ToolFailure({
+              message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`
+            });
+          }
+          if (replacements > 1 && input.replaceAll !== true) {
+            return yield* new ToolFailure({
+              message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`
+            });
+          }
+          const replacementBom = replaced.startsWith("\uFEFF");
+          const result = yield* fileMutation.write({
+            target,
+            content: Bom.join(replaced, original.bom || replacementBom)
+          });
+          const bom = original.bom || replacementBom;
+          const formatted = (yield* formatter.file(target.absolute)) ? yield* exports_file_mutation.syncTextBom(environment.files, target.absolute, bom) : (yield* exports_file_mutation.readText(environment.files, target.absolute)).text;
+          return {
+            files: [fileDiff(result.resource, source, formatted)],
+            replacements
+          };
+        }).pipe(fileMutation.withLock([path.resolve(location.directory, input.path)]), Effect.map((output) => ({
+          output,
+          content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to edit ${input.path}`, error })));
+      }
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, Plugin, exports_edit };