@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-k0h8v1wk.js

@@ -0,0 +1,172 @@
+import {
+  exports_markdown
+} from "./ripgrep-7wcmqxrc.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_migrate
+} from "./ripgrep-3mfgaav1.js";
+import {
+  exports_agent as exports_agent2
+} from "./ripgrep-4s2xwh5d.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/agent.ts
+var exports_agent3 = {};
+__export(exports_agent3, {
+  Plugin: () => Plugin,
+  ConfigAgentPlugin: () => exports_agent3
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Document, Info } from "@opencode-ai/schema/config";
+import { ConfigAgent } from "@opencode-ai/schema/config/agent";
+import path from "path";
+import { Effect, Option, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+var legacySources = [
+  { pattern: "{agent,agents}/**/*.md", primary: false },
+  { pattern: "{mode,modes}/*.md", primary: true }
+];
+var sourceDirectories = ["agent", "agents", "mode", "modes"];
+var decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info);
+var decodeLegacyAgent = Schema.decodeUnknownOption(exports_agent2.Info);
+var decodeConfig = Schema.decodeUnknownOption(Info);
+var pathActions = ["external_directory", "read", "edit"];
+var agentKeys = new Set([
+  "model",
+  "variant",
+  "request",
+  "system",
+  "description",
+  "mode",
+  "hidden",
+  "color",
+  "steps",
+  "disabled",
+  "permissions"
+]);
+var Plugin = define({
+  id: "opencode.config.agent",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), (entry) => {
+        if (entry.type === "document")
+          return Effect.succeed([entry]);
+        if (entry.type !== "directory")
+          return Effect.succeed([]);
+        return Effect.gen(function* () {
+          const files = yield* discover(fs, entry.path);
+          return yield* Effect.forEach(files, (file) => fs.readFileStringSafe(file.filepath).pipe(Effect.map((content) => content ? decode(file, content) : undefined), Effect.catch(() => Effect.succeed(undefined)))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+        });
+      }).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.agent.reload()));
+    const sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))));
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"));
+    yield* Stream.merge(sourceChanges, configUpdates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.agent.transform((draft) => {
+      const permissions = expandPermissions(loaded.documents.flatMap((document) => document.info.permissions ?? []), global.home);
+      const configuredDefault = exports_config.latest(loaded.documents, "default_agent");
+      if (configuredDefault !== undefined)
+        draft.default(exports_agent.ID.make(configuredDefault));
+      for (const current of draft.list()) {
+        draft.update(current.id, (agent) => agent.permissions.push(...permissions));
+      }
+      for (const document of loaded.documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = exports_agent.ID.make(id);
+          if (item.disabled) {
+            draft.remove(agentID);
+            continue;
+          }
+          const exists = draft.get(agentID) !== undefined;
+          draft.update(agentID, (agent) => {
+            if (!exists)
+              agent.permissions.push(...permissions);
+            if (item.model !== undefined)
+              agent.model = {
+                id: item.model.model,
+                providerID: item.model.providerID,
+                ...item.model.variant === undefined ? {} : { variant: item.model.variant }
+              };
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {});
+              Object.assign(agent.request.body, item.request.body ?? {});
+            }
+            if (item.system !== undefined)
+              agent.system = item.system;
+            if (item.description !== undefined)
+              agent.description = item.description;
+            if (item.mode !== undefined)
+              agent.mode = item.mode;
+            if (item.hidden !== undefined)
+              agent.hidden = item.hidden;
+            if (item.color !== undefined)
+              agent.color = item.color;
+            if (item.steps !== undefined)
+              agent.steps = item.steps;
+            if (item.permissions !== undefined) {
+              agent.permissions.push(...expandPermissions(item.permissions, global.home));
+            }
+          });
+        }
+      }
+    });
+  })
+});
+function isAgentSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function expandPermissions(rules, home) {
+  return rules.map((rule) => isPathAction(rule.action) ? { ...rule, resource: expandHome(rule.resource, home) } : rule);
+}
+function isPathAction(action) {
+  return pathActions.some((item) => item === action);
+}
+function expandHome(resource, home) {
+  if (resource === "~")
+    return home;
+  if (resource === "$HOME")
+    return home;
+  const relative = resource.startsWith("~/") ? resource.slice(2) : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\") ? resource.slice(6) : undefined;
+  if (relative !== undefined)
+    return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative);
+  return resource;
+}
+function discover(fs, directory) {
+  return Effect.forEach(legacySources, (source) => fs.scan(source.pattern, { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.map((files) => files.toSorted().map((filepath) => ({ directory, filepath, primary: source.primary }))))).pipe(Effect.map((files) => files.flat()), Effect.catch(() => Effect.succeed([])));
+}
+function decode(file, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return;
+  const name = path.relative(file.directory, file.filepath).replaceAll("\\", "/").replace(/^(agent|agents|mode|modes)\//, "").replace(/\.md$/, "");
+  const body = markdown.content.trim();
+  const legacy = Object.keys(markdown.data).some((key) => !agentKeys.has(key));
+  const agent = legacy ? Option.getOrUndefined(Option.map(decodeLegacyAgent({ name, ...markdown.data, prompt: body }, { errors: "all", propertyOrder: "original" }), exports_migrate.migrateAgent)) : Option.getOrUndefined(decodeAgent({ ...markdown.data, system: body }, { errors: "all", propertyOrder: "original" }));
+  if (!agent)
+    return;
+  const info = Option.getOrUndefined(decodeConfig({
+    agents: { [name]: file.primary ? { ...agent, mode: "primary" } : agent }
+  }));
+  if (!info)
+    return;
+  return new Document({ type: "document", path: AbsolutePath.make(file.filepath), info });
+}
+
+export { Plugin, exports_agent3 as exports_agent };

package/dist/chunks/ripgrep-k1qrb68g.js

@@ -0,0 +1,36 @@
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/sdk.ts
+var exports_sdk = {};
+__export(exports_sdk, {
+  node: () => node,
+  layer: () => layer,
+  Updated: () => Updated,
+  Service: () => Service,
+  SdkPlugins: () => exports_sdk
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Updated = exports_bus.ephemeral({ type: "sdk.plugin.updated", schema: {} });
+
+class Service extends Context.Service()("@opencode/SdkPlugins") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const plugins = new Map;
+  let revision = 0;
+  return Service.of({
+    register: (plugin) => Effect.sync(() => {
+      plugins.set(plugin.id, { ...plugin, version: String(++revision) });
+    }).pipe(Effect.andThen(bus.publish(Updated, {})), Effect.asVoid),
+    all: () => [...plugins.values()]
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_bus.node] });
+
+export { Updated, Service, layer, node, exports_sdk };

package/dist/chunks/ripgrep-kcwh27nh.js

@@ -0,0 +1,470 @@
+import {
+  AbsolutePath,
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_keyed_mutex
+} from "./ripgrep-0kvmztkf.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/git.ts
+var exports_git = {};
+__export(exports_git, {
+  node: () => node,
+  WorktreeError: () => WorktreeError,
+  Worktree: () => Worktree,
+  TreeID: () => TreeID,
+  Service: () => Service,
+  Repository: () => Repository,
+  OperationError: () => OperationError,
+  Git: () => exports_git
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { AppProcess } from "@opencode-ai/util/process";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Repository extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath,
+  gitDirectory: AbsolutePath,
+  commonDirectory: AbsolutePath
+}) {
+}
+var snapshotConfigFile = "opencode.gitconfig";
+var snapshotConfigInclude = `[include]
+	path = ${snapshotConfigFile}
+`;
+var snapshotConfig = `[core]
+	autocrlf = false
+	longpaths = true
+	symlinks = true
+	fsmonitor = false
+	untrackedCache = true
+[feature]
+	manyFiles = true
+[index]
+	version = 4
+	threads = true
+`;
+var TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"));
+
+class OperationError extends Schema.TaggedErrorClass()("Git.OperationError", {
+  operation: Schema.Literals([
+    "clone",
+    "fetch",
+    "checkout",
+    "reset",
+    "create",
+    "refresh",
+    "write_tree",
+    "list_files",
+    "diff",
+    "restore"
+  ]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Worktree extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath,
+  kind: Schema.Literals(["main", "linked"])
+}) {
+}
+
+class WorktreeError extends Schema.TaggedErrorClass()("Git.WorktreeError", {
+  operation: Schema.Literals(["create", "remove", "list"]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath),
+  forceRequired: Schema.optional(Schema.Boolean),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Git") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const proc = yield* AppProcess.Service;
+  const locks = exports_keyed_mutex.makeUnsafe();
+  const locked = (repository, effect) => locks.withLock(repository.gitDirectory)(effect);
+  const discover = Effect.fn("Git.repo.discover")(function* (input) {
+    const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.catch(() => Effect.succeed(undefined)));
+    if (!dotgit)
+      return;
+    const cwd = path.dirname(dotgit);
+    const result = yield* run(cwd, proc)(["rev-parse", "--git-dir", "--git-common-dir", "--show-toplevel"]);
+    const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
+    if (!gitDir || !commonDir)
+      return;
+    return new Repository({
+      worktree: AbsolutePath.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
+      gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir)),
+      commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir))
+    });
+  });
+  const remote = Effect.fn("Git.remote.get")(function* (repository, name = "origin") {
+    const result = yield* run(repository.worktree, proc)(["remote", "get-url", name]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const roots = Effect.fn("Git.history.rootCommits")(function* (repository) {
+    const result = yield* run(repository.worktree, proc)(["rev-list", "--max-parents=0", "HEAD"]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text.split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted();
+  });
+  const head = Effect.fn("Git.history.head")(function* (repository) {
+    const result = yield* run(repository.worktree, proc)(["rev-parse", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const branch = Effect.fn("Git.history.branch")(function* (repository) {
+    const result = yield* run(repository.worktree, proc)(["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const remoteHead = Effect.fn("Git.history.defaultRemoteBranch")(function* (repository, remoteName = "origin") {
+    const result = yield* run(repository.worktree, proc)(["symbolic-ref", `refs/remotes/${remoteName}/HEAD`]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
+  });
+  const operation = Effect.fnUntraced(function* (operation2, directory, args) {
+    const result = yield* execute(directory, proc)(args).pipe(Effect.mapError((cause) => new OperationError({ operation: operation2, directory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return;
+    return yield* new OperationError({
+      operation: operation2,
+      directory,
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation2} failed`
+    });
+  });
+  const clone = Effect.fn("Git.repo.clone")(function* (input) {
+    yield* operation("clone", AbsolutePath.make(path.dirname(input.directory)), [
+      "clone",
+      "--depth",
+      String(input.depth ?? 100),
+      ...input.branch ? ["--branch", input.branch] : [],
+      "--",
+      input.remote,
+      input.directory
+    ]);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new OperationError({
+      operation: "clone",
+      directory: input.directory,
+      message: "Cloned repository could not be opened"
+    });
+  });
+  const fetch = Effect.fn("Git.sync.fetchRemotes")(function* (repository, input = {}) {
+    yield* operation("fetch", repository.worktree, ["fetch", "--all", ...input.prune === false ? [] : ["--prune"]]);
+  });
+  const fetchBranch = Effect.fn("Git.sync.fetchBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    const spec = `refs/heads/${input.branch}:refs/remotes/${remoteName}/${input.branch}`;
+    yield* operation("fetch", repository.worktree, ["fetch", remoteName, input.force === false ? spec : `+${spec}`]);
+  });
+  const checkout = Effect.fn("Git.sync.checkoutRemoteBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    yield* operation("checkout", repository.worktree, [
+      "checkout",
+      ...input.reset === false ? [input.branch] : ["-B", input.branch, `${remoteName}/${input.branch}`]
+    ]);
+  });
+  const reset = Effect.fn("Git.sync.resetHard")(function* (repository, revision) {
+    yield* operation("reset", repository.worktree, ["reset", "--hard", revision]);
+  });
+  const repositoryArgs = (repository, args) => [
+    "--git-dir",
+    repository.gitDirectory,
+    "--work-tree",
+    repository.worktree,
+    ...args
+  ];
+  const repositoryOperation = Effect.fnUntraced(function* (operationName, repository, args, options) {
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(repository, args), {
+      cwd: repository.worktree,
+      env: options?.env,
+      extendEnv: true
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError({
+      operation: operationName,
+      directory: repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    const text = result.stdout.toString("utf8");
+    if (result.exitCode === 0)
+      return { text, stderr: result.stderr.toString("utf8") };
+    return yield* new OperationError({
+      operation: operationName,
+      directory: repository.worktree,
+      message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`
+    });
+  });
+  const create = Effect.fn("Git.repo.create")(function* (input) {
+    yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "create",
+      directory: input.gitDirectory,
+      message: "Failed to create Git storage",
+      cause
+    })));
+    const repository = new Repository({
+      worktree: input.worktree,
+      gitDirectory: input.gitDirectory,
+      commonDirectory: input.gitDirectory
+    });
+    yield* repositoryOperation("create", repository, ["init"]);
+    yield* Effect.gen(function* () {
+      yield* fs.writeFileString(path.join(input.gitDirectory, snapshotConfigFile), snapshotConfig);
+      const config = path.join(input.gitDirectory, "config");
+      const current = yield* fs.readFileString(config);
+      if (current.includes(snapshotConfigInclude))
+        return;
+      yield* fs.writeFileString(config, `${current.endsWith(`
+`) ? `
+` : `
+
+`}${snapshotConfigInclude}`, {
+        flag: "a"
+      });
+    }).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "create",
+      directory: input.gitDirectory,
+      message: "Failed to configure Git storage",
+      cause
+    })));
+    if (!input.seed)
+      return repository;
+    yield* fs.ensureDir(path.join(input.gitDirectory, "objects", "info")).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "create",
+      directory: input.gitDirectory,
+      message: "Failed to configure shared Git objects",
+      cause
+    })));
+    yield* fs.writeFileString(path.join(input.gitDirectory, "objects", "info", "alternates"), path.join(input.seed.commonDirectory, "objects") + `
+`).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "create",
+      directory: input.gitDirectory,
+      message: "Failed to configure shared Git objects",
+      cause
+    })));
+    yield* fs.copyFile(path.join(input.seed.gitDirectory, "index"), path.join(input.gitDirectory, "index")).pipe(Effect.catch(() => Effect.void));
+    return repository;
+  });
+  const refresh = Effect.fn("Git.index.refresh")(function* (input) {
+    const list = (args) => repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => result.text.split("\x00").filter(Boolean)));
+    const [tracked, untracked] = yield* Effect.all([
+      list(["diff-files", "--name-only", "-z", "--", input.scope]),
+      list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope])
+    ], { concurrency: 2 });
+    const candidates = Array.from(new Set([...tracked, ...untracked]));
+    if (!candidates.length)
+      return { skipped: [] };
+    const ignored2 = input.ignores ? new Set((yield* repositoryOperation("refresh", input.ignores, ["check-ignore", "--no-index", "--stdin", "-z"], {
+      stdin: candidates.join("\x00") + "\x00"
+    }).pipe(Effect.catch(() => Effect.succeed({ text: "", stderr: "" })))).text.split("\x00").filter(Boolean)) : new Set;
+    const allowed = candidates.filter((item) => !ignored2.has(item));
+    const maximum = input.maximumUntrackedFileBytes;
+    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(item)), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath.make(item) : undefined), Effect.catch(() => Effect.succeed(undefined))), { concurrency: 8 })).filter((item) => item !== undefined) : [];
+    const stage = allowed.filter((item) => !skipped.includes(RelativePath.make(item)));
+    const remove = [...ignored2, ...skipped];
+    if (remove.length)
+      yield* repositoryOperation("refresh", input.repository, ["rm", "--cached", "-f", "--ignore-unmatch", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: remove.join("\x00") + "\x00" });
+    if (stage.length)
+      yield* repositoryOperation("refresh", input.repository, ["add", "--all", "--sparse", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: stage.join("\x00") + "\x00" });
+    return { skipped };
+  });
+  const ignored = Effect.fn("Git.index.ignored")(function* (input) {
+    if (!input.paths.length)
+      return new Set;
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
+      cwd: input.repository.worktree,
+      extendEnv: true
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "list_files",
+      directory: input.repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    if (result.exitCode !== 0 && result.exitCode !== 1)
+      return yield* new OperationError({
+        operation: "list_files",
+        directory: input.repository.worktree,
+        message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
+      });
+    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath.make(file)));
+  });
+  const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
+    return TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+  });
+  const captureTree = Effect.fn("Git.tree.capture")((input) => locked(input.repository, Effect.gen(function* () {
+    yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true });
+    return yield* writeTree(input.repository);
+  })));
+  const treeFiles = Effect.fn("Git.tree.files")(function* (input) {
+    return (yield* repositoryOperation("list_files", input.repository, [
+      "diff",
+      "--name-only",
+      "-z",
+      input.from,
+      input.to
+    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath.make(file));
+  });
+  const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
+    const paths = input.paths ?? (yield* treeFiles(input));
+    return yield* Effect.forEach(paths, (file) => Effect.gen(function* () {
+      const statusText = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--name-status",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.trim();
+      const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified";
+      const stats = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--numstat",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.split("\t");
+      const binary = stats[0] === "-" || stats[1] === "-";
+      const patch = binary ? "" : (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        `--unified=${input.context ?? 3}`,
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text;
+      return {
+        file,
+        status,
+        additions: binary ? 0 : Number(stats[0] ?? 0),
+        deletions: binary ? 0 : Number(stats[1] ?? 0),
+        patch
+      };
+    }));
+  });
+  const entry = Effect.fnUntraced(function* (repository, tree, file) {
+    const text = (yield* repositoryOperation("restore", repository, [
+      "ls-tree",
+      "-z",
+      tree,
+      "--",
+      file
+    ])).text.replace(/\0$/, "");
+    if (!text)
+      return;
+    const match = text.match(/^(\d+)\s+\w+\s+([0-9a-f]+)\t/);
+    if (!match)
+      return yield* new OperationError({
+        operation: "restore",
+        directory: repository.worktree,
+        message: `Invalid tree entry for ${file}`
+      });
+    return { mode: match[1], object: match[2] };
+  });
+  const restore = Effect.fn("Git.tree.restore")((input) => locked(input.repository, Effect.forEach(input.files, ([file, tree]) => Effect.gen(function* () {
+    if (yield* entry(input.repository, tree, file)) {
+      yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file]);
+      return;
+    }
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError({
+      operation: "restore",
+      directory: input.repository.worktree,
+      message: `Failed to remove ${file}`,
+      cause
+    })));
+  }), { discard: true })));
+  const worktreeRun = Effect.fnUntraced(function* (operation2, repository, args, worktreeDirectory, cwd = repository.worktree) {
+    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError({ operation: operation2, directory: worktreeDirectory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return result.stdout.toString("utf8");
+    const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Git failed";
+    return yield* new WorktreeError({
+      operation: operation2,
+      directory: worktreeDirectory,
+      message,
+      forceRequired: operation2 === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+    });
+  });
+  const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
+    yield* worktreeRun("create", input.repository, ["worktree", "add", "--detach", input.directory, "HEAD"], input.directory);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new WorktreeError({
+      operation: "create",
+      directory: input.directory,
+      message: "Created worktree could not be opened"
+    });
+  });
+  const worktreeRemove = Effect.fn("Git.worktree.remove")(function* (input) {
+    yield* worktreeRun("remove", input.repository, ["worktree", "remove", ...input.force ? ["--force"] : [], input.directory], input.directory, input.repository.commonDirectory);
+  });
+  const worktreeList = Effect.fn("Git.worktree.list")(function* (repository) {
+    return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"])).split(`
+`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree({
+      directory: AbsolutePath.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+      kind: index === 0 ? "main" : "linked"
+    }));
+  });
+  return Service.of({
+    repo: { discover, clone, create },
+    remote: { get: remote },
+    history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
+    sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
+    worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
+    index: { refresh, ignored },
+    tree: {
+      capture: captureTree,
+      write: writeTree,
+      files: treeFiles,
+      diff: treeDiff,
+      restore
+    }
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node, AppProcess.node] });
+function run(cwd, proc) {
+  return (args) => execute(cwd, proc)(args).pipe(Effect.catch(() => Effect.succeed({ exitCode: 1, text: "", stderr: "" })));
+}
+function execute(cwd, proc) {
+  return (args) => proc.run(ChildProcess.make("git", args, {
+    cwd,
+    extendEnv: true,
+    stdin: "ignore"
+  })).pipe(Effect.map((result) => ({
+    exitCode: result.exitCode,
+    text: result.stdout.toString("utf8"),
+    stderr: result.stderr.toString("utf8")
+  })));
+}
+function resolvePath(cwd, value) {
+  const trimmed = value.replace(/[\r\n]+$/, "");
+  if (!trimmed)
+    return cwd;
+  const normalized = FSUtil.windowsPath(trimmed);
+  if (path.isAbsolute(normalized))
+    return path.normalize(normalized);
+  return path.resolve(cwd, normalized);
+}
+
+export { Repository, TreeID, OperationError, Worktree, WorktreeError, Service, node, exports_git };