alchemylab-opencode 1.0.10 → 1.0.12

package/dist/chunk-EPJAWJV7.js

@@ -0,0 +1,728 @@
+// Built by esbuild from opencode-server source
+if (typeof globalThis.Bun === 'undefined') {
+  globalThis.Bun = {
+    version: '0.0.0-node-compat',
+    stdin: { async text() { const chunks = []; for await (const c of process.stdin) chunks.push(c); return Buffer.concat(chunks).toString(); } },
+    which(cmd) { try { return require('child_process').execFileSync('which', [cmd], { encoding: 'utf8' }).trim(); } catch { return null; } },
+  };
+}
+if (typeof globalThis.__name === 'undefined') { globalThis.__name = (t, n) => { Object.defineProperty(t, 'name', { value: n, configurable: true }); return t; }; }
+if (typeof globalThis.__export === 'undefined') { globalThis.__export = (t, a) => { for (const k in a) Object.defineProperty(t, k, { get: a[k], enumerable: true }); }; }
+
+import {
+  ShareNext
+} from "./chunk-MHT2AKV6.js";
+import {
+  Command,
+  File,
+  FileWatcher,
+  Format,
+  Git,
+  LSP,
+  Plugin,
+  Slug,
+  Snapshot,
+  WorkspaceID
+} from "./chunk-W7LNDS5C.js";
+import {
+  Bus,
+  errorMessage
+} from "./chunk-IMDQIMHW.js";
+import {
+  AppFileSystem,
+  BusEvent,
+  Database,
+  Global,
+  GlobalBus,
+  Instance,
+  InstanceState,
+  Log,
+  NamedError,
+  Project,
+  ProjectID,
+  ProjectTable,
+  db_exports,
+  defaultLayer,
+  makeRuntime
+} from "./chunk-3PZZ2D23.js";
+
+// packages/opencode/src/worktree/index.ts
+import z2 from "zod";
+
+// packages/opencode/src/project/vcs.ts
+import { Effect, Layer, ServiceMap, Stream } from "effect";
+import path from "path";
+import z from "zod";
+var Vcs;
+((Vcs2) => {
+  const log = Log.create({ service: "vcs" });
+  const count = (text) => {
+    if (!text) return 0;
+    if (!text.endsWith("\n")) return text.split("\n").length;
+    return text.slice(0, -1).split("\n").length;
+  };
+  const work = Effect.fnUntraced(function* (fs, cwd, file) {
+    const full = path.join(cwd, file);
+    if (!(yield* fs.exists(full).pipe(Effect.orDie))) return "";
+    const buf = yield* fs.readFile(full).pipe(Effect.catch(() => Effect.succeed(new Uint8Array())));
+    if (Buffer.from(buf).includes(0)) return "";
+    return Buffer.from(buf).toString("utf8");
+  });
+  const nums = (list) => new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }]));
+  const merge = (...lists) => {
+    const out = /* @__PURE__ */ new Map();
+    lists.flat().forEach((item) => {
+      if (!out.has(item.file)) out.set(item.file, item);
+    });
+    return [...out.values()];
+  };
+  const files = Effect.fnUntraced(function* (fs, git, cwd, ref, list, map) {
+    const base = ref ? yield* git.prefix(cwd) : "";
+    const next = yield* Effect.forEach(
+      list,
+      (item) => Effect.gen(function* () {
+        const before = item.status === "added" || !ref ? "" : yield* git.show(cwd, ref, item.file, base);
+        const after = item.status === "deleted" ? "" : yield* work(fs, cwd, item.file);
+        const stat = map.get(item.file);
+        return {
+          file: item.file,
+          before,
+          after,
+          additions: stat?.additions ?? (item.status === "added" ? count(after) : 0),
+          deletions: stat?.deletions ?? (item.status === "deleted" ? count(before) : 0),
+          status: item.status
+        };
+      }),
+      { concurrency: 8 }
+    );
+    return next.toSorted((a, b) => a.file.localeCompare(b.file));
+  });
+  const track = Effect.fnUntraced(function* (fs, git, cwd, ref) {
+    if (!ref) return yield* files(fs, git, cwd, ref, yield* git.status(cwd), /* @__PURE__ */ new Map());
+    const [list, stats] = yield* Effect.all([git.status(cwd), git.stats(cwd, ref)], { concurrency: 2 });
+    return yield* files(fs, git, cwd, ref, list, nums(stats));
+  });
+  const compare = Effect.fnUntraced(function* (fs, git, cwd, ref) {
+    const [list, stats, extra] = yield* Effect.all([git.diff(cwd, ref), git.stats(cwd, ref), git.status(cwd)], {
+      concurrency: 3
+    });
+    return yield* files(
+      fs,
+      git,
+      cwd,
+      ref,
+      merge(
+        list,
+        extra.filter((item) => item.code === "??")
+      ),
+      nums(stats)
+    );
+  });
+  Vcs2.Mode = z.enum(["git", "branch"]);
+  Vcs2.Event = {
+    BranchUpdated: BusEvent.define(
+      "vcs.branch.updated",
+      z.object({
+        branch: z.string().optional()
+      })
+    )
+  };
+  Vcs2.Info = z.object({
+    branch: z.string().optional(),
+    default_branch: z.string().optional()
+  }).meta({
+    ref: "VcsInfo"
+  });
+  class Service extends ServiceMap.Service()("@opencode/Vcs") {
+  }
+  Vcs2.Service = Service;
+  Vcs2.layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* AppFileSystem.Service;
+      const git = yield* Git.Service;
+      const bus = yield* Bus.Service;
+      const state = yield* InstanceState.make(
+        Effect.fn("Vcs.state")(
+          (ctx) => Effect.gen(function* () {
+            if (ctx.project.vcs !== "git") {
+              return { current: void 0, root: void 0 };
+            }
+            const get = Effect.fnUntraced(function* () {
+              return yield* git.branch(ctx.directory);
+            });
+            const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
+              concurrency: 2
+            });
+            const value = { current, root };
+            log.info("initialized", { branch: value.current, default_branch: value.root?.name });
+            yield* bus.subscribe(FileWatcher.Event.Updated).pipe(
+              Stream.filter((evt) => evt.properties.file.endsWith("HEAD")),
+              Stream.runForEach(
+                (_evt) => Effect.gen(function* () {
+                  const next = yield* get();
+                  if (next !== value.current) {
+                    log.info("branch changed", { from: value.current, to: next });
+                    value.current = next;
+                    yield* bus.publish(Vcs2.Event.BranchUpdated, { branch: next });
+                  }
+                })
+              ),
+              Effect.forkScoped
+            );
+            return value;
+          })
+        )
+      );
+      return Service.of({
+        init: Effect.fn("Vcs.init")(function* () {
+          yield* InstanceState.get(state);
+        }),
+        branch: Effect.fn("Vcs.branch")(function* () {
+          return yield* InstanceState.use(state, (x) => x.current);
+        }),
+        defaultBranch: Effect.fn("Vcs.defaultBranch")(function* () {
+          return yield* InstanceState.use(state, (x) => x.root?.name);
+        }),
+        diff: Effect.fn("Vcs.diff")(function* (mode) {
+          const value = yield* InstanceState.get(state);
+          if (Instance.project.vcs !== "git") return [];
+          if (mode === "git") {
+            return yield* track(
+              fs,
+              git,
+              Instance.directory,
+              (yield* git.hasHead(Instance.directory)) ? "HEAD" : void 0
+            );
+          }
+          if (!value.root) return [];
+          if (value.current && value.current === value.root.name) return [];
+          const ref = yield* git.mergeBase(Instance.directory, value.root.ref);
+          if (!ref) return [];
+          return yield* compare(fs, git, Instance.directory, ref);
+        })
+      });
+    })
+  );
+  const defaultLayer2 = Vcs2.layer.pipe(
+    Layer.provide(Git.defaultLayer),
+    Layer.provide(AppFileSystem.defaultLayer),
+    Layer.provide(Bus.layer)
+  );
+  const { runPromise } = makeRuntime(Service, defaultLayer2);
+  async function init() {
+    return runPromise((svc) => svc.init());
+  }
+  Vcs2.init = init;
+  async function branch() {
+    return runPromise((svc) => svc.branch());
+  }
+  Vcs2.branch = branch;
+  async function defaultBranch() {
+    return runPromise((svc) => svc.defaultBranch());
+  }
+  Vcs2.defaultBranch = defaultBranch;
+  async function diff(mode) {
+    return runPromise((svc) => svc.diff(mode));
+  }
+  Vcs2.diff = diff;
+})(Vcs || (Vcs = {}));
+
+// packages/opencode/src/project/bootstrap.ts
+async function InstanceBootstrap() {
+  Log.Default.info("bootstrapping", { directory: Instance.directory });
+  await Plugin.init();
+  ShareNext.init();
+  Format.init();
+  await LSP.init();
+  File.init();
+  FileWatcher.init();
+  Vcs.init();
+  Snapshot.init();
+  Bus.subscribe(Command.Event.Executed, async (payload) => {
+    if (payload.properties.name === Command.Default.INIT) {
+      Project.setInitialized(Instance.project.id);
+    }
+  });
+}
+
+// packages/opencode/src/worktree/index.ts
+import { Effect as Effect2, Layer as Layer2, Path, Scope, ServiceMap as ServiceMap2, Stream as Stream2 } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { NodePath } from "@effect/platform-node";
+var Worktree;
+((Worktree2) => {
+  const log = Log.create({ service: "worktree" });
+  Worktree2.Event = {
+    Ready: BusEvent.define(
+      "worktree.ready",
+      z2.object({
+        name: z2.string(),
+        branch: z2.string()
+      })
+    ),
+    Failed: BusEvent.define(
+      "worktree.failed",
+      z2.object({
+        message: z2.string()
+      })
+    )
+  };
+  Worktree2.Info = z2.object({
+    name: z2.string(),
+    branch: z2.string(),
+    directory: z2.string()
+  }).meta({
+    ref: "Worktree"
+  });
+  Worktree2.CreateInput = z2.object({
+    name: z2.string().optional(),
+    startCommand: z2.string().optional().describe("Additional startup script to run after the project's start command")
+  }).meta({
+    ref: "WorktreeCreateInput"
+  });
+  Worktree2.RemoveInput = z2.object({
+    directory: z2.string()
+  }).meta({
+    ref: "WorktreeRemoveInput"
+  });
+  Worktree2.ResetInput = z2.object({
+    directory: z2.string()
+  }).meta({
+    ref: "WorktreeResetInput"
+  });
+  Worktree2.NotGitError = NamedError.create(
+    "WorktreeNotGitError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  Worktree2.NameGenerationFailedError = NamedError.create(
+    "WorktreeNameGenerationFailedError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  Worktree2.CreateFailedError = NamedError.create(
+    "WorktreeCreateFailedError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  Worktree2.StartCommandFailedError = NamedError.create(
+    "WorktreeStartCommandFailedError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  Worktree2.RemoveFailedError = NamedError.create(
+    "WorktreeRemoveFailedError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  Worktree2.ResetFailedError = NamedError.create(
+    "WorktreeResetFailedError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+  function slugify(input) {
+    return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  }
+  function failedRemoves(...chunks) {
+    return chunks.filter(Boolean).flatMap(
+      (chunk) => chunk.split("\n").map((line) => line.trim()).flatMap((line) => {
+        const match = line.match(/^warning:\s+failed to remove\s+(.+):\s+/i);
+        if (!match) return [];
+        const value = match[1]?.trim().replace(/^['"]|['"]$/g, "");
+        if (!value) return [];
+        return [value];
+      })
+    );
+  }
+  class Service extends ServiceMap2.Service()("@opencode/Worktree") {
+  }
+  Worktree2.Service = Service;
+  Worktree2.layer = Layer2.effect(
+    Service,
+    Effect2.gen(function* () {
+      const scope = yield* Scope.Scope;
+      const fs = yield* AppFileSystem.Service;
+      const pathSvc = yield* Path.Path;
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+      const project = yield* Project.Service;
+      const git = Effect2.fnUntraced(
+        function* (args, opts) {
+          const handle = yield* spawner.spawn(
+            ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" })
+          );
+          const [text, stderr] = yield* Effect2.all(
+            [Stream2.mkString(Stream2.decodeText(handle.stdout)), Stream2.mkString(Stream2.decodeText(handle.stderr))],
+            { concurrency: 2 }
+          );
+          const code = yield* handle.exitCode;
+          return { code, text, stderr };
+        },
+        Effect2.scoped,
+        Effect2.catch(
+          (e) => Effect2.succeed({ code: 1, text: "", stderr: e instanceof Error ? e.message : String(e) })
+        )
+      );
+      const MAX_NAME_ATTEMPTS = 26;
+      const candidate = Effect2.fn("Worktree.candidate")(function* (root, base) {
+        const ctx = yield* InstanceState.context;
+        for (const attempt of Array.from({ length: MAX_NAME_ATTEMPTS }, (_, i) => i)) {
+          const name = base ? attempt === 0 ? base : `${base}-${Slug.create()}` : Slug.create();
+          const branch = `opencode/${name}`;
+          const directory = pathSvc.join(root, name);
+          if (yield* fs.exists(directory).pipe(Effect2.orDie)) continue;
+          const ref = `refs/heads/${branch}`;
+          const branchCheck = yield* git(["show-ref", "--verify", "--quiet", ref], { cwd: ctx.worktree });
+          if (branchCheck.code === 0) continue;
+          return Worktree2.Info.parse({ name, branch, directory });
+        }
+        throw new Worktree2.NameGenerationFailedError({ message: "Failed to generate a unique worktree name" });
+      });
+      const makeWorktreeInfo2 = Effect2.fn("Worktree.makeWorktreeInfo")(function* (name) {
+        const ctx = yield* InstanceState.context;
+        if (ctx.project.vcs !== "git") {
+          throw new Worktree2.NotGitError({ message: "Worktrees are only supported for git projects" });
+        }
+        const root = pathSvc.join(Global.Path.data, "worktree", ctx.project.id);
+        yield* fs.makeDirectory(root, { recursive: true }).pipe(Effect2.orDie);
+        const base = name ? slugify(name) : "";
+        return yield* candidate(root, base || void 0);
+      });
+      const setup = Effect2.fnUntraced(function* (info) {
+        const ctx = yield* InstanceState.context;
+        const created = yield* git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
+          cwd: ctx.worktree
+        });
+        if (created.code !== 0) {
+          throw new Worktree2.CreateFailedError({ message: created.stderr || created.text || "Failed to create git worktree" });
+        }
+        yield* project.addSandbox(ctx.project.id, info.directory).pipe(Effect2.catch(() => Effect2.void));
+      });
+      const boot = Effect2.fnUntraced(function* (info, startCommand) {
+        const ctx = yield* InstanceState.context;
+        const projectID = ctx.project.id;
+        const extra = startCommand?.trim();
+        const populated = yield* git(["reset", "--hard"], { cwd: info.directory });
+        if (populated.code !== 0) {
+          const message = populated.stderr || populated.text || "Failed to populate worktree";
+          log.error("worktree checkout failed", { directory: info.directory, message });
+          GlobalBus.emit("event", {
+            directory: info.directory,
+            payload: { type: Worktree2.Event.Failed.type, properties: { message } }
+          });
+          return;
+        }
+        const booted = yield* Effect2.promise(
+          () => Instance.provide({
+            directory: info.directory,
+            init: InstanceBootstrap,
+            fn: () => void 0
+          }).then(() => true).catch((error) => {
+            const message = errorMessage(error);
+            log.error("worktree bootstrap failed", { directory: info.directory, message });
+            GlobalBus.emit("event", {
+              directory: info.directory,
+              payload: { type: Worktree2.Event.Failed.type, properties: { message } }
+            });
+            return false;
+          })
+        );
+        if (!booted) return;
+        GlobalBus.emit("event", {
+          directory: info.directory,
+          payload: {
+            type: Worktree2.Event.Ready.type,
+            properties: { name: info.name, branch: info.branch }
+          }
+        });
+        yield* runStartScripts(info.directory, { projectID, extra });
+      });
+      const createFromInfo2 = Effect2.fn("Worktree.createFromInfo")(function* (info, startCommand) {
+        yield* setup(info);
+        yield* boot(info, startCommand);
+      });
+      const create2 = Effect2.fn("Worktree.create")(function* (input) {
+        const info = yield* makeWorktreeInfo2(input?.name);
+        yield* setup(info);
+        yield* boot(info, input?.startCommand).pipe(
+          Effect2.catchCause((cause) => Effect2.sync(() => log.error("worktree bootstrap failed", { cause }))),
+          Effect2.forkIn(scope)
+        );
+        return info;
+      });
+      const canonical = Effect2.fnUntraced(function* (input) {
+        const abs = pathSvc.resolve(input);
+        const real = yield* fs.realPath(abs).pipe(Effect2.catch(() => Effect2.succeed(abs)));
+        const normalized = pathSvc.normalize(real);
+        return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+      });
+      function parseWorktreeList(text) {
+        return text.split("\n").map((line) => line.trim()).reduce((acc, line) => {
+          if (!line) return acc;
+          if (line.startsWith("worktree ")) {
+            acc.push({ path: line.slice("worktree ".length).trim() });
+            return acc;
+          }
+          const current = acc[acc.length - 1];
+          if (!current) return acc;
+          if (line.startsWith("branch ")) {
+            current.branch = line.slice("branch ".length).trim();
+          }
+          return acc;
+        }, []);
+      }
+      const locateWorktree = Effect2.fnUntraced(function* (entries, directory) {
+        for (const item of entries) {
+          if (!item.path) continue;
+          const key = yield* canonical(item.path);
+          if (key === directory) return item;
+        }
+        return void 0;
+      });
+      function stopFsmonitor(target) {
+        return fs.exists(target).pipe(
+          Effect2.orDie,
+          Effect2.flatMap((exists) => exists ? git(["fsmonitor--daemon", "stop"], { cwd: target }) : Effect2.void)
+        );
+      }
+      function cleanDirectory(target) {
+        return Effect2.promise(
+          () => import("fs/promises").then((fsp) => fsp.rm(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })).catch((error) => {
+            const message = errorMessage(error);
+            throw new Worktree2.RemoveFailedError({ message: message || "Failed to remove git worktree directory" });
+          })
+        );
+      }
+      const remove2 = Effect2.fn("Worktree.remove")(function* (input) {
+        if (Instance.project.vcs !== "git") {
+          throw new Worktree2.NotGitError({ message: "Worktrees are only supported for git projects" });
+        }
+        const directory = yield* canonical(input.directory);
+        const list = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree });
+        if (list.code !== 0) {
+          throw new Worktree2.RemoveFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" });
+        }
+        const entries = parseWorktreeList(list.text);
+        const entry = yield* locateWorktree(entries, directory);
+        if (!entry?.path) {
+          const directoryExists = yield* fs.exists(directory).pipe(Effect2.orDie);
+          if (directoryExists) {
+            yield* stopFsmonitor(directory);
+            yield* cleanDirectory(directory);
+          }
+          return true;
+        }
+        yield* stopFsmonitor(entry.path);
+        const removed = yield* git(["worktree", "remove", "--force", entry.path], { cwd: Instance.worktree });
+        if (removed.code !== 0) {
+          const next = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree });
+          if (next.code !== 0) {
+            throw new Worktree2.RemoveFailedError({
+              message: removed.stderr || removed.text || next.stderr || next.text || "Failed to remove git worktree"
+            });
+          }
+          const stale = yield* locateWorktree(parseWorktreeList(next.text), directory);
+          if (stale?.path) {
+            throw new Worktree2.RemoveFailedError({ message: removed.stderr || removed.text || "Failed to remove git worktree" });
+          }
+        }
+        yield* cleanDirectory(entry.path);
+        const branch = entry.branch?.replace(/^refs\/heads\//, "");
+        if (branch) {
+          const deleted = yield* git(["branch", "-D", branch], { cwd: Instance.worktree });
+          if (deleted.code !== 0) {
+            throw new Worktree2.RemoveFailedError({
+              message: deleted.stderr || deleted.text || "Failed to delete worktree branch"
+            });
+          }
+        }
+        return true;
+      });
+      const gitExpect = Effect2.fnUntraced(function* (args, opts, error) {
+        const result = yield* git(args, opts);
+        if (result.code !== 0) throw error(result);
+        return result;
+      });
+      const runStartCommand = Effect2.fnUntraced(
+        function* (directory, cmd) {
+          const [shell, args] = process.platform === "win32" ? ["cmd", ["/c", cmd]] : ["bash", ["-lc", cmd]];
+          const handle = yield* spawner.spawn(
+            ChildProcess.make(shell, args, { cwd: directory, extendEnv: true, stdin: "ignore" })
+          );
+          const [, stderr] = yield* Effect2.all(
+            [Stream2.runDrain(handle.stdout), Stream2.mkString(Stream2.decodeText(handle.stderr))],
+            { concurrency: 2 }
+          ).pipe(Effect2.orDie);
+          const code = yield* handle.exitCode;
+          return { code, stderr };
+        },
+        Effect2.scoped,
+        Effect2.catch(() => Effect2.succeed({ code: 1, stderr: "" }))
+      );
+      const runStartScript = Effect2.fnUntraced(function* (directory, cmd, kind) {
+        const text = cmd.trim();
+        if (!text) return true;
+        const result = yield* runStartCommand(directory, text);
+        if (result.code === 0) return true;
+        log.error("worktree start command failed", { kind, directory, message: result.stderr });
+        return false;
+      });
+      const runStartScripts = Effect2.fnUntraced(function* (directory, input) {
+        const row = yield* Effect2.sync(
+          () => Database.use((db) => db.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, input.projectID)).get())
+        );
+        const project2 = row ? Project.fromRow(row) : void 0;
+        const startup = project2?.commands?.start?.trim() ?? "";
+        const ok = yield* runStartScript(directory, startup, "project");
+        if (!ok) return false;
+        yield* runStartScript(directory, input.extra ?? "", "worktree");
+        return true;
+      });
+      const prune = Effect2.fnUntraced(function* (root, entries) {
+        const base = yield* canonical(root);
+        yield* Effect2.forEach(
+          entries,
+          (entry) => Effect2.gen(function* () {
+            const target = yield* canonical(pathSvc.resolve(root, entry));
+            if (target === base) return;
+            if (!target.startsWith(`${base}${pathSvc.sep}`)) return;
+            yield* fs.remove(target, { recursive: true }).pipe(Effect2.ignore);
+          }),
+          { concurrency: "unbounded" }
+        );
+      });
+      const sweep = Effect2.fnUntraced(function* (root) {
+        const first = yield* git(["clean", "-ffdx"], { cwd: root });
+        if (first.code === 0) return first;
+        const entries = failedRemoves(first.stderr, first.text);
+        if (!entries.length) return first;
+        yield* prune(root, entries);
+        return yield* git(["clean", "-ffdx"], { cwd: root });
+      });
+      const reset2 = Effect2.fn("Worktree.reset")(function* (input) {
+        if (Instance.project.vcs !== "git") {
+          throw new Worktree2.NotGitError({ message: "Worktrees are only supported for git projects" });
+        }
+        const directory = yield* canonical(input.directory);
+        const primary = yield* canonical(Instance.worktree);
+        if (directory === primary) {
+          throw new Worktree2.ResetFailedError({ message: "Cannot reset the primary workspace" });
+        }
+        const list = yield* git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree });
+        if (list.code !== 0) {
+          throw new Worktree2.ResetFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" });
+        }
+        const entry = yield* locateWorktree(parseWorktreeList(list.text), directory);
+        if (!entry?.path) {
+          throw new Worktree2.ResetFailedError({ message: "Worktree not found" });
+        }
+        const worktreePath = entry.path;
+        const base = yield* Effect2.promise(() => Git.defaultBranch(Instance.worktree));
+        if (!base) {
+          throw new Worktree2.ResetFailedError({ message: "Default branch not found" });
+        }
+        const sep = base.ref.indexOf("/");
+        if (base.ref !== base.name && sep > 0) {
+          const remote = base.ref.slice(0, sep);
+          const branch = base.ref.slice(sep + 1);
+          yield* gitExpect(
+            ["fetch", remote, branch],
+            { cwd: Instance.worktree },
+            (r) => new Worktree2.ResetFailedError({ message: r.stderr || r.text || `Failed to fetch ${base.ref}` })
+          );
+        }
+        yield* gitExpect(
+          ["reset", "--hard", base.ref],
+          { cwd: worktreePath },
+          (r) => new Worktree2.ResetFailedError({ message: r.stderr || r.text || "Failed to reset worktree to target" })
+        );
+        const cleanResult = yield* sweep(worktreePath);
+        if (cleanResult.code !== 0) {
+          throw new Worktree2.ResetFailedError({ message: cleanResult.stderr || cleanResult.text || "Failed to clean worktree" });
+        }
+        yield* gitExpect(
+          ["submodule", "update", "--init", "--recursive", "--force"],
+          { cwd: worktreePath },
+          (r) => new Worktree2.ResetFailedError({ message: r.stderr || r.text || "Failed to update submodules" })
+        );
+        yield* gitExpect(
+          ["submodule", "foreach", "--recursive", "git", "reset", "--hard"],
+          { cwd: worktreePath },
+          (r) => new Worktree2.ResetFailedError({ message: r.stderr || r.text || "Failed to reset submodules" })
+        );
+        yield* gitExpect(
+          ["submodule", "foreach", "--recursive", "git", "clean", "-fdx"],
+          { cwd: worktreePath },
+          (r) => new Worktree2.ResetFailedError({ message: r.stderr || r.text || "Failed to clean submodules" })
+        );
+        const status = yield* git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath });
+        if (status.code !== 0) {
+          throw new Worktree2.ResetFailedError({ message: status.stderr || status.text || "Failed to read git status" });
+        }
+        if (status.text.trim()) {
+          throw new Worktree2.ResetFailedError({ message: `Worktree reset left local changes:
+${status.text.trim()}` });
+        }
+        yield* runStartScripts(worktreePath, { projectID: Instance.project.id }).pipe(
+          Effect2.catchCause((cause) => Effect2.sync(() => log.error("worktree start task failed", { cause }))),
+          Effect2.forkIn(scope)
+        );
+        return true;
+      });
+      return Service.of({ makeWorktreeInfo: makeWorktreeInfo2, createFromInfo: createFromInfo2, create: create2, remove: remove2, reset: reset2 });
+    })
+  );
+  const defaultLayer2 = Worktree2.layer.pipe(
+    Layer2.provide(defaultLayer),
+    Layer2.provide(Project.defaultLayer),
+    Layer2.provide(AppFileSystem.defaultLayer),
+    Layer2.provide(NodePath.layer)
+  );
+  const { runPromise } = makeRuntime(Service, defaultLayer2);
+  async function makeWorktreeInfo(name) {
+    return runPromise((svc) => svc.makeWorktreeInfo(name));
+  }
+  Worktree2.makeWorktreeInfo = makeWorktreeInfo;
+  async function createFromInfo(info, startCommand) {
+    return runPromise((svc) => svc.createFromInfo(info, startCommand));
+  }
+  Worktree2.createFromInfo = createFromInfo;
+  async function create(input) {
+    return runPromise((svc) => svc.create(input));
+  }
+  Worktree2.create = create;
+  async function remove(input) {
+    return runPromise((svc) => svc.remove(input));
+  }
+  Worktree2.remove = remove;
+  async function reset(input) {
+    return runPromise((svc) => svc.reset(input));
+  }
+  Worktree2.reset = reset;
+})(Worktree || (Worktree = {}));
+
+// packages/opencode/src/control-plane/types.ts
+import z3 from "zod";
+var WorkspaceInfo = z3.object({
+  id: WorkspaceID.zod,
+  type: z3.string(),
+  branch: z3.string().nullable(),
+  name: z3.string().nullable(),
+  directory: z3.string().nullable(),
+  extra: z3.unknown().nullable(),
+  projectID: ProjectID.zod
+});
+
+export {
+  Vcs,
+  InstanceBootstrap,
+  Worktree,
+  WorkspaceInfo
+};
+//# sourceMappingURL=chunk-EPJAWJV7.js.map