@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-k9enfjvq.js

@@ -0,0 +1,124 @@
+import {
+  exports_runner
+} from "./location-mutation-cz3dkvcz.js";
+import {
+  exports_inbox
+} from "./location-mutation-8v2yzmx6.js";
+import {
+  toSessionError
+} from "./location-mutation-57ny1p8n.js";
+import {
+  exports_run_coordinator
+} from "./location-mutation-nj1s64cz.js";
+import {
+  exports_store
+} from "./location-mutation-qea62gnn.js";
+import {
+  UserInterruptedError
+} from "./location-mutation-s6by3cc4.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+import {
+  exports_location_service_map
+} from "./location-mutation-zdkg1k91.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/execution.ts
+var exports_execution = {};
+__export(exports_execution, {
+  terminal: () => terminal,
+  noopLayer: () => noopLayer,
+  node: () => node,
+  layer: () => layer,
+  SessionExecution: () => exports_execution,
+  Service: () => Service
+});
+import { Cause, Context, Effect, Exit, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/SessionExecution") {
+}
+function terminal(exit, reason) {
+  if (Exit.isSuccess(exit))
+    return { type: "succeeded" };
+  if (Cause.hasInterrupts(exit.cause))
+    return { type: "interrupted", reason: reason ?? "shutdown" };
+  const failure = Cause.squash(exit.cause);
+  if (failure instanceof UserInterruptedError)
+    return { type: "interrupted", reason: "user" };
+  return { type: "failed", error: toSessionError(failure) };
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const store = yield* exports_store.Service;
+  const locations = yield* exports_location_service_map.Service;
+  const bus = yield* exports_bus.Service;
+  const db = (yield* exports_database.Service).db;
+  const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
+  const claimOnCommit = (sessionID) => ({
+    commit: () => store.claim(sessionID)
+  });
+  const releaseOnCommit = (sessionID) => ({
+    commit: () => store.release(sessionID)
+  });
+  function drain(sessionID, force, continuation, promotable = "input") {
+    return Effect.gen(function* () {
+      const session = yield* store.get(sessionID);
+      if (!session)
+        return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+      const result = yield* exports_runner.Service.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(Effect.provide(locations.get(session.location)), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+      if (result.type === "complete")
+        return;
+      return yield* drain(sessionID, false, result.continuation, promotable);
+    });
+  }
+  const coordinator = yield* exports_run_coordinator.make({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+    drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
+    settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
+      const outcome = terminal(exit, reason);
+      if (outcome.type === "succeeded") {
+        yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        return;
+      }
+      if (outcome.type === "interrupted") {
+        yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        return;
+      }
+      yield* bus.publish(SessionEvent.Execution.Failed, {
+        sessionID,
+        error: outcome.error
+      }, releaseOnCommit(sessionID));
+    }))
+  });
+  return Service.of({
+    active: coordinator.active,
+    interrupt: (sessionID, options) => coordinator.interrupt(sessionID, "user", options?.continue ? { continue: { request: "steer", when: exports_inbox.has(db, sessionID, "steer") } } : undefined),
+    resume: coordinator.run,
+    wake: coordinator.wake,
+    wakeActive: coordinator.wakeActive,
+    awaitIdle: coordinator.awaitIdle
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [exports_store.node, exports_location_service_map.node, exports_bus.node, exports_database.node]
+});
+var noopLayer = Layer.succeed(Service, Service.of({
+  active: Effect.succeed(new Set),
+  resume: () => Effect.void,
+  wake: () => Effect.void,
+  wakeActive: () => Effect.void,
+  interrupt: () => Effect.void,
+  awaitIdle: () => Effect.void
+}));
+
+export { Service, terminal, layer, node, noopLayer, exports_execution };

package/dist/chunks/location-mutation-kcwh27nh.js

@@ -0,0 +1,470 @@
+import {
+  AbsolutePath,
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  exports_keyed_mutex
+} from "./location-mutation-0kvmztkf.js";
+import {
+  __export
+} from "./location-mutation-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 };

package/dist/chunks/location-mutation-kg1345f7.js

@@ -0,0 +1,63 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/filesystem/protected.ts
+var exports_protected = {};
+__export(exports_protected, {
+  paths: () => paths,
+  names: () => names,
+  isHome: () => isHome,
+  Protected: () => exports_protected
+});
+import os from "os";
+import path from "path";
+var home = os.homedir();
+function isHome(directory) {
+  return path.resolve(directory) === path.resolve(home);
+}
+var DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "Public",
+  "Applications",
+  "Library"
+];
+var DARWIN_LIBRARY = [
+  "Application Support/AddressBook",
+  "Calendars",
+  "Mail",
+  "Messages",
+  "Safari",
+  "Cookies",
+  "Application Support/com.apple.TCC",
+  "PersonalizationPortrait",
+  "Metadata/CoreSpotlight",
+  "Suggestions"
+];
+var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
+var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
+function names() {
+  if (process.platform === "darwin")
+    return new Set(DARWIN_HOME);
+  if (process.platform === "win32")
+    return new Set(WIN32_HOME);
+  return new Set;
+}
+function paths() {
+  if (process.platform === "darwin")
+    return [
+      ...DARWIN_HOME.map((name) => path.join(home, name)),
+      ...DARWIN_LIBRARY.map((name) => path.join(home, "Library", name)),
+      ...DARWIN_ROOT
+    ];
+  if (process.platform === "win32")
+    return WIN32_HOME.map((name) => path.join(home, name));
+  return [];
+}
+
+export { isHome, names, paths, exports_protected };

package/dist/chunks/location-mutation-kpdbz7gn.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260423070820_add_icon_url_override.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260423070820_add_icon_url_override",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        ALTER TABLE \`project\` ADD \`icon_url_override\` text;
+        UPDATE \`project\` SET \`icon_url_override\` = \`icon_url\` WHERE \`icon_url\` IS NOT NULL;
+      `);
+    });
+  }
+};
+var _20260423070820_add_icon_url_override_default = migration;
+
+export { _20260423070820_add_icon_url_override_default };