@opencode/core 2.0.25 → 2.0.26

package/dist/chunks/variant-hs1x7rht.js

@@ -1,466 +0,0 @@
-import {
-  AbsolutePath2,
-  RelativePath2
-} from "./variant-z5v4ffb3.js";
-import {
-  makeUnsafe2
-} from "./variant-dpkg50ah.js";
-import {
-  MAX_TOTAL_PATCH_BYTES2,
-  emptyPatch2,
-  chunksByFile2
-} from "./variant-tazgh4e4.js";
-import {
-  gitExecutable2
-} from "./variant-ef5x83kb.js";
-import {
-  __export
-} from "./variant-9rqn6x4v.js";
-
-// src/git.ts
-var exports_git3 = {};
-__export(exports_git3, {
-  Git: () => exports_git3,
-  OperationError: () => OperationError3,
-  Repository: () => Repository2,
-  Service: () => Service82,
-  TreeID: () => TreeID2,
-  Worktree: () => Worktree2,
-  WorktreeError: () => WorktreeError2,
-  node: () => node86
-});
-import path from "path";
-import { Context, Effect, Layer, Schema } from "effect";
-import { ChildProcess } from "effect/unstable/process";
-import { FSUtil } from "@opencode/util/fs-util";
-import { AppProcess } from "@opencode/util/process";
-import { makeGlobalNode } from "@opencode/util/effect/app-node";
-class Repository2 extends Schema.Class("Git.Repository")({
-  worktree: AbsolutePath2,
-  gitDirectory: AbsolutePath2,
-  commonDirectory: AbsolutePath2
-}) {
-}
-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 TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
-
-class OperationError3 extends Schema.TaggedError()("Git.OperationError", {
-  operation: Schema.Literals([
-    "clone",
-    "fetch",
-    "checkout",
-    "reset",
-    "create",
-    "refresh",
-    "write_tree",
-    "list_files",
-    "diff",
-    "restore"
-  ]),
-  message: Schema.String,
-  directory: Schema.optional(AbsolutePath2),
-  cause: Schema.optional(Schema.Defect())
-}) {
-}
-
-class Worktree2 extends Schema.Class("Git.Worktree")({
-  directory: AbsolutePath2,
-  kind: Schema.Literals(["main", "linked"])
-}) {
-}
-
-class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
-  operation: Schema.Literals(["create", "remove", "list"]),
-  message: Schema.String,
-  directory: Schema.optional(AbsolutePath2),
-  forceRequired: Schema.optional(Schema.Boolean),
-  cause: Schema.optional(Schema.Defect())
-}) {
-}
-
-class Service82 extends Context.Service()("@opencode/Git") {
-}
-var layer = Layer.effect(Service82, Effect.gen(function* () {
-  const fs = yield* FSUtil.Service;
-  const proc = yield* AppProcess.Service;
-  const locks = makeUnsafe2();
-  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.orElseSucceed(() => {
-      return;
-    }));
-    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 Repository2({
-      worktree: AbsolutePath2.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
-      gitDirectory: AbsolutePath2.make(resolvePath(cwd, gitDir)),
-      commonDirectory: AbsolutePath2.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* (operation, directory, args) {
-    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError3({ operation, directory, message: cause.message, cause })));
-    if (result.exitCode === 0)
-      return;
-    return yield* new OperationError3({
-      operation,
-      directory,
-      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
-    });
-  });
-  const clone = Effect.fn("Git.repo.clone")(function* (input) {
-    yield* operation("clone", AbsolutePath2.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 OperationError3({
-      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(gitExecutable2, repositoryArgs(repository, args), {
-      cwd: repository.worktree,
-      env: options?.env,
-      extendEnv: true
-    }), { stdin: options?.stdin, maxOutputBytes: options?.maxOutputBytes }).pipe(Effect.mapError((cause) => new OperationError3({
-      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"), truncated: result.stdoutTruncated };
-    return yield* new OperationError3({
-      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) {
-    const operationError = (message) => (cause) => new OperationError3({ operation: "create", directory: input.gitDirectory, message, cause });
-    yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
-    const repository = new Repository2({
-      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(operationError("Failed to configure Git storage")));
-    if (!input.seed)
-      return repository;
-    yield* fs.ensureDir(path.join(input.gitDirectory, "objects", "info")).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
-    yield* fs.writeFileString(path.join(input.gitDirectory, "objects", "info", "alternates"), path.join(input.seed.commonDirectory, "objects") + `
-`).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
-    yield* fs.copyFile(path.join(input.seed.gitDirectory, "index"), path.join(input.gitDirectory, "index")).pipe(Effect.ignore);
-    return repository;
-  });
-  const refresh = Effect.fn("Git.index.refresh")(function* (input) {
-    const list = (args) => repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => nuls(result.text)));
-    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])).map((file) => RelativePath2.make(file));
-    if (!candidates.length)
-      return { skipped: [] };
-    const excluded = input.ignores ? yield* ignored({ repository: input.ignores, paths: candidates }) : new Set;
-    const allowed = candidates.filter((item) => !excluded.has(item));
-    const maximum = input.maximumUntrackedFileBytes;
-    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath2.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath2.make(item) : undefined), Effect.orElseSucceed(() => {
-      return;
-    })), { concurrency: 8 })).filter((item) => item !== undefined) : [];
-    const stage = allowed.filter((item) => !skipped.includes(item));
-    const remove = [...excluded, ...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(gitExecutable2, 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 OperationError3({
-      operation: "list_files",
-      directory: input.repository.worktree,
-      message: cause.message,
-      cause
-    })));
-    if (result.exitCode !== 0 && result.exitCode !== 1)
-      return yield* new OperationError3({
-        operation: "list_files",
-        directory: input.repository.worktree,
-        message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
-      });
-    return new Set(nuls(result.stdout.toString("utf8")).map((file) => RelativePath2.make(file)));
-  });
-  const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
-    return TreeID2.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 nuls((yield* repositoryOperation("list_files", input.repository, [
-      "diff",
-      "--name-only",
-      "--no-renames",
-      "-z",
-      input.from,
-      input.to
-    ])).text).map((file) => RelativePath2.make(file));
-  });
-  const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
-    if (input.paths?.length === 0)
-      return [];
-    const args = ["--no-renames", input.from, input.to, "--", ...input.paths ?? []];
-    const [names, numbers, patch] = yield* Effect.all([
-      repositoryOperation("diff", input.repository, ["diff", "--name-status", "-z", ...args]),
-      repositoryOperation("diff", input.repository, ["diff", "--numstat", "-z", ...args]),
-      repositoryOperation("diff", input.repository, ["-c", "core.quotepath=false", "diff", "--no-ext-diff", `--unified=${input.context ?? 3}`, ...args], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES2 })
-    ], { concurrency: 3 });
-    const statuses = nuls(names.text);
-    const files = statuses.flatMap((code, index) => {
-      const file = statuses[index + 1];
-      if (index % 2 !== 0 || !file)
-        return [];
-      return [
-        {
-          file: RelativePath2.make(file),
-          status: code.startsWith("A") ? "added" : code.startsWith("D") ? "deleted" : "modified"
-        }
-      ];
-    });
-    const stats = new Map(nuls(numbers.text).flatMap((line) => {
-      const [additions, deletions, ...file] = line.split("\t");
-      if (!additions || !deletions || file.length === 0)
-        return [];
-      return [
-        [
-          file.join("\t"),
-          additions === "-" || deletions === "-" ? { binary: true, additions: 0, deletions: 0 } : { binary: false, additions: Number(additions), deletions: Number(deletions) }
-        ]
-      ];
-    }));
-    const patches = chunksByFile2(patch, (index) => files[index]?.file);
-    return files.map((entry) => {
-      const stat = stats.get(entry.file);
-      return {
-        ...entry,
-        additions: stat?.additions ?? 0,
-        deletions: stat?.deletions ?? 0,
-        patch: stat?.binary ? "" : patches.get(entry.file) ?? emptyPatch2(entry.file)
-      };
-    });
-  });
-  const hasEntry = Effect.fnUntraced(function* (repository, tree, file) {
-    const text = (yield* repositoryOperation("restore", repository, [
-      "ls-tree",
-      "-z",
-      tree,
-      "--",
-      file
-    ])).text.replace(/\0$/, "");
-    if (!text)
-      return false;
-    if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
-      return yield* new OperationError3({
-        operation: "restore",
-        directory: repository.worktree,
-        message: `Invalid tree entry for ${file}`
-      });
-    return true;
-  });
-  const restore = Effect.fn("Git.tree.restore")((input) => locked(input.repository, Effect.forEach(input.files, ([file, tree]) => Effect.gen(function* () {
-    if (yield* hasEntry(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 OperationError3({
-      operation: "restore",
-      directory: input.repository.worktree,
-      message: `Failed to remove ${file}`,
-      cause
-    })));
-  }), { discard: true })));
-  const worktreeRun = Effect.fnUntraced(function* (operation, repository, args, worktreeDirectory, cwd = repository.worktree) {
-    const result = yield* proc.run(ChildProcess.make(gitExecutable2, args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError2({ operation, 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 WorktreeError2({
-      operation,
-      directory: worktreeDirectory,
-      message,
-      forceRequired: operation === "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, input.ref ?? "HEAD"], input.directory);
-    const repository = yield* discover(input.directory);
-    if (repository)
-      return repository;
-    return yield* new WorktreeError2({
-      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 Worktree2({
-      directory: AbsolutePath2.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
-      kind: index === 0 ? "main" : "linked"
-    }));
-  });
-  return Service82.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 node86 = makeGlobalNode({ service: Service82, layer, deps: [FSUtil.node, AppProcess.node] });
-function run(cwd, proc, args) {
-  return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
-}
-function execute(cwd, proc, args) {
-  return proc.run(ChildProcess.make(gitExecutable2, args, {
-    cwd,
-    extendEnv: true,
-    stdin: "ignore"
-  })).pipe(Effect.map((result) => ({
-    exitCode: result.exitCode,
-    text: result.stdout.toString("utf8"),
-    stderr: result.stderr.toString("utf8")
-  })));
-}
-function nuls(text) {
-  return text.split("\x00").filter(Boolean);
-}
-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 { Repository2, TreeID2, OperationError3, Worktree2, WorktreeError2, Service82, node86, exports_git3 };