@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-je6c5z5p.js

@@ -0,0 +1,470 @@
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./repository-tazgh4e4.js";
+import {
+  DiffError2
+} from "./repository-xp6wb0v9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/vcs/git.ts
+var exports_git = {};
+__export(exports_git, {
+  Plugin: () => Plugin37,
+  VcsGitPlugin: () => exports_git
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { AppProcess } from "@opencode/util/process";
+var Plugin37 = define({
+  id: "opencode.vcs.git",
+  effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
+    const location = yield* Service66;
+    if (location.vcs?.type !== "git")
+      return;
+    const processes = yield* AppProcess.Service;
+    const adapter = make(processes, {
+      directory: location.directory,
+      worktree: location.project.directory
+    });
+    yield* ctx.vcs.transform((editor) => {
+      editor.add({
+        id: "git",
+        name: "Git",
+        info: () => adapter.info(),
+        base: () => adapter.base(),
+        branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
+        status: () => adapter.status(),
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
+      });
+    });
+  })
+});
+function make(proc, input) {
+  const ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree };
+  return {
+    info: Effect.fn("VcsGit.info")(function* () {
+      const [current, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
+        concurrency: 2
+      });
+      return { branch: { current, default: root?.name } };
+    }),
+    base: () => ctx.git.base(ctx.directory),
+    branches: Effect.fn("VcsGit.branches")(function* (options) {
+      return yield* ctx.git.branches(ctx.directory, options);
+    }),
+    status: Effect.fn("VcsGit.status")(function* () {
+      const git = ctx.git;
+      const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined;
+      const [list, stats] = yield* Effect.all([git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])], { concurrency: 2 });
+      const map = nums(stats);
+      return yield* Effect.forEach(list.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined);
+        return {
+          file: item.file,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsGit.diff")(function* (mode, options) {
+      const git = ctx.git;
+      if (mode === "working") {
+        return yield* track(ctx, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options);
+      }
+      if (!(yield* git.hasHead(ctx.directory))) {
+        return mode === "committed" ? [] : yield* track(ctx, undefined, options);
+      }
+      const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
+      const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
+      if (!ref) {
+        return yield* new DiffError2({
+          message: base ? `No merge base available for ${base}` : "No review base available"
+        });
+      }
+      return yield* diffAgainstRef(ctx, ref, { ...options, target: mode === "committed" ? "HEAD" : undefined });
+    })
+  };
+}
+var cfg = [
+  "--no-optional-locks",
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "core.longpaths=true",
+  "-c",
+  "core.symlinks=true",
+  "-c",
+  "core.quotepath=false"
+];
+var kind = (code) => {
+  if (code === "??")
+    return "added";
+  if (code.includes("U"))
+    return "modified";
+  if (code.includes("A") && !code.includes("D"))
+    return "added";
+  if (code.includes("D") && !code.includes("A"))
+    return "deleted";
+  return "modified";
+};
+var nuls = (text) => text.split("\x00").filter(Boolean);
+function makeGit(proc) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("git", [...cfg, ...args], {
+      cwd: opts.cwd,
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.orElseSucceed(() => ({ exitCode: 1, text: () => "", truncated: false })));
+  const text = Effect.fnUntraced(function* (args, opts) {
+    return (yield* run(args, opts)).text();
+  });
+  const lines = Effect.fnUntraced(function* (args, opts) {
+    return (yield* text(args, opts)).split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+  });
+  const configured = Effect.fnUntraced(function* (cwd, list) {
+    const result = yield* run(["config", "init.defaultBranch"], { cwd });
+    const name = result.text().trim();
+    if (!name || !list.includes(name))
+      return;
+    return { name, ref: name };
+  });
+  const primary = Effect.fnUntraced(function* (cwd) {
+    const list = yield* lines(["remote"], { cwd });
+    if (list.includes("origin"))
+      return "origin";
+    if (list.length === 1)
+      return list[0];
+    if (list.includes("upstream"))
+      return "upstream";
+    return list[0];
+  });
+  const branch = Effect.fn("VcsGit.branch")(function* (cwd) {
+    const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const branches = Effect.fn("VcsGit.branches")(function* (cwd, options) {
+    const search = options?.search?.trim().replace(/[*?[\]\\]/g, "\\$&");
+    return (yield* lines([
+      "for-each-ref",
+      "--ignore-case",
+      "--sort=refname",
+      "--sort=-committerdate",
+      "--format=%(refname:short)",
+      ...options?.limit ? [`--count=${options.limit}`] : [],
+      ...search ? [`refs/heads/*${search}*`, `refs/remotes/*${search}*`] : ["refs/heads", "refs/remotes"]
+    ], { cwd })).filter((item) => !item.endsWith("/HEAD"));
+  });
+  const defaultBranch = Effect.fn("VcsGit.defaultBranch")(function* (cwd) {
+    const remote = yield* primary(cwd);
+    if (remote) {
+      const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd });
+      if (head.exitCode === 0) {
+        const ref = head.text().trim().replace(/^refs\/remotes\//, "");
+        const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : "";
+        if (name)
+          return { name, ref };
+      }
+    }
+    const list = yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd });
+    const next = yield* configured(cwd, list);
+    if (next)
+      return next;
+    if (list.includes("main"))
+      return { name: "main", ref: "main" };
+    if (list.includes("master"))
+      return { name: "master", ref: "master" };
+  });
+  const resolve = Effect.fnUntraced(function* (cwd, ref) {
+    const result = yield* run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fnUntraced(function* (cwd, commit, ref) {
+    if (!/^[a-f0-9]{40,64}$/.test(commit))
+      return false;
+    return (yield* run(["merge-base", "--is-ancestor", commit, ref], { cwd })).exitCode === 0;
+  });
+  const namedRef = Effect.fnUntraced(function* (cwd, input) {
+    if (input === "HEAD" || input.endsWith("/HEAD") || /[~^:@{}\s]/.test(input))
+      return;
+    const ref = (yield* text(["rev-parse", "--symbolic-full-name", "--verify", "--end-of-options", input], {
+      cwd
+    })).trim();
+    if (!/^refs\/(heads|remotes)\/.+/.test(ref) || ref.endsWith("/HEAD") || !(yield* resolve(cwd, ref)))
+      return;
+    return { name: ref.replace(/^refs\/heads\//, "").replace(/^refs\/remotes\/[^/]+\//, ""), ref };
+  });
+  const base = Effect.fn("VcsGit.base")(function* (cwd) {
+    if (!(yield* hasHead(cwd)))
+      return null;
+    const current = yield* branch(cwd);
+    if (!current)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
+      cwd
+    })).flatMap((line) => {
+      const match = /^([a-f0-9]+)\0(.+)$/.exec(line);
+      return match ? [{ commit: match[1], message: match[2] }] : [];
+    });
+    const renamed = history.some((entry) => entry.message.startsWith("Branch: renamed "));
+    const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
+    const origin = creation?.message.slice("branch: Created from ".length);
+    if (creation && origin) {
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
+      }
+    }
+    const root = yield* defaultBranch(cwd);
+    if (!root || current !== root.name)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const candidate = yield* namedRef(cwd, root.ref);
+    if (!candidate)
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
+    return { name: root.name, ref: candidate.ref, source: "default" };
+  });
+  const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
+    const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
+    return result.exitCode === 0;
+  });
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
+    if (!ref)
+      return;
+    const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const status = Effect.fn("VcsGit.statusNames")(function* (cwd) {
+    return nuls(yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], { cwd })).flatMap((item) => {
+      const file = item.slice(3);
+      if (!file)
+        return [];
+      const code = item.slice(0, 2);
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
+    const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
+    if (result.exitCode !== 0)
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
+    const list = nuls(result.text());
+    return list.flatMap((code, idx) => {
+      if (idx % 2 !== 0)
+        return [];
+      const file = list[idx + 1];
+      if (!code || !file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref, target) {
+    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, ...target ? [target] : [], "--", "."], { cwd })).flatMap((item) => {
+      const a = item.indexOf("\t");
+      const b = item.indexOf("\t", a + 1);
+      if (a === -1 || b === -1)
+        return [];
+      const file = item.slice(b + 1);
+      if (!file)
+        return [];
+      const adds = item.slice(0, a);
+      const dels = item.slice(a + 1, b);
+      const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10);
+      const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10);
+      return [
+        {
+          file,
+          additions: Number.isFinite(additions) ? additions : 0,
+          deletions: Number.isFinite(deletions) ? deletions : 0
+        }
+      ];
+    });
+  });
+  const patch = Effect.fn("VcsGit.patch")(function* (cwd, ref, file, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const patchAll = Effect.fn("VcsGit.patchAll")(function* (cwd, ref, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      "."
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const patchUntracked = Effect.fn("VcsGit.patchUntracked")(function* (cwd, file, options) {
+    const result = yield* run([
+      "diff",
+      "--no-index",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      "--",
+      "/dev/null",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const statUntracked = Effect.fn("VcsGit.statUntracked")(function* (cwd, file) {
+    const result = yield* run(["diff", "--no-index", "--numstat", "--", "/dev/null", file], {
+      cwd,
+      maxOutputBytes: 4096
+    });
+    if (result.truncated)
+      return;
+    const parts = result.text().split("\t");
+    if (parts.length < 2)
+      return;
+    const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] || "0", 10);
+    const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] || "0", 10);
+    return {
+      file,
+      additions: Number.isFinite(additions) ? additions : 0,
+      deletions: Number.isFinite(deletions) ? deletions : 0
+    };
+  });
+  return {
+    branch,
+    branches,
+    base,
+    defaultBranch,
+    hasHead,
+    mergeBase,
+    status,
+    diff,
+    stats,
+    patch,
+    patchAll,
+    patchUntracked,
+    statUntracked
+  };
+}
+var nums = (list) => new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }]));
+var merge = (...lists) => {
+  const out = new Map;
+  lists.flat().forEach((item) => {
+    if (!out.has(item.file))
+      out.set(item.file, item);
+  });
+  return [...out.values()];
+};
+var emptyBatch = () => ({ patches: new Map, capped: false });
+var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
+  if (list.length === 0)
+    return emptyBatch();
+  const result = yield* ctx.git.patchAll(ctx.directory, ref, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
+  });
+  return {
+    patches: chunksByFile2(result, (index) => list[index]?.file),
+    capped: result.truncated
+  };
+});
+var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
+  const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  });
+  if (!result.truncated && result.text)
+    return result.text;
+  return emptyPatch2(item.file);
+});
+var totalPatch = (file, patch, total) => {
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
+    return { patch, capped: false };
+  return { patch: emptyPatch2(file), capped: true };
+};
+var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
+  if (capped)
+    return emptyPatch2(item.file);
+  const batched = batch.patches.get(item.file);
+  if (batched !== undefined)
+    return batched;
+  if (item.code !== "??" && batch.capped)
+    return emptyPatch2(item.file);
+  return yield* nativePatch(ctx, ref, item, options);
+});
+var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
+  const next = [];
+  let total = 0;
+  let capped = false;
+  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
+    const stat = map.get(item.file) ?? (!options?.target && item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
+    const patch = yield* patchForItem(ctx, ref, item, batch, capped, options);
+    const result = capped ? { patch, capped: true } : totalPatch(item.file, patch, total);
+    capped = capped || result.capped;
+    if (!capped) {
+      total += Buffer.byteLength(result.patch);
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
+    }
+    next.push({
+      file: item.file,
+      patch: result.patch,
+      additions: stat?.additions ?? 0,
+      deletions: stat?.deletions ?? 0,
+      status: item.status
+    });
+  }
+  return next;
+});
+var diffAgainstRef = Effect.fnUntraced(function* (ctx, ref, options) {
+  const [list, stats, extra] = yield* Effect.all([
+    ctx.git.diff(ctx.directory, ref, options?.target),
+    ctx.git.stats(ctx.directory, ref, options?.target),
+    options?.target ? Effect.succeed([]) : ctx.git.status(ctx.directory)
+  ], { concurrency: 3 });
+  return yield* files(ctx, ref, merge(list, extra.filter((item) => item.code === "??")), nums(stats), yield* batchPatches(ctx, ref, list, options), options);
+});
+var track = Effect.fnUntraced(function* (ctx, ref, options) {
+  if (!ref)
+    return yield* files(ctx, ref, yield* ctx.git.status(ctx.directory), new Map, emptyBatch(), options);
+  return yield* diffAgainstRef(ctx, ref, options);
+});
+
+export { Plugin37, exports_git };

package/dist/chunks/repository-jqh9b0xq.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Plugin: () => exports_service,
+  Service: () => Service36,
+  awaitActivation: () => awaitActivation2
+});
+import { Context } from "effect";
+
+class Service36 extends Context.Service()("@opencode/Plugin") {
+}
+var awaitActivation2 = Service36.use((plugins) => plugins.awaitActivation);
+
+export { Service36, awaitActivation2, exports_service };

package/dist/chunks/repository-jr7sbwjy.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260309230000_move_org_to_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260309230000_move_org_to_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`);
+      yield* tx.run(`UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`);
+      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`);
+    });
+  }
+};
+var _20260309230000_move_org_to_state_default = migration;
+
+export { _20260309230000_move_org_to_state_default };

package/dist/chunks/repository-jwfs4k6c.js

@@ -0,0 +1,41 @@
+// src/database/migration/20260604172448_event_sourced_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260604172448_event_sourced_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`event_aggregate_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_session_input\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`admitted_seq\` integer NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_input\` RENAME TO \`session_input\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_admitted_seq_idx\` ON \`session_input\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_promoted_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`);`);
+    });
+  }
+};
+var _20260604172448_event_sourced_session_input_default = migration;
+
+export { _20260604172448_event_sourced_session_input_default };

package/dist/chunks/repository-jwjk52g2.js

@@ -0,0 +1,77 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/opencode.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  MoveInput: () => MoveInput2,
+  OpenCodeTools: () => exports_opencode,
+  Plugin: () => Plugin29,
+  RenameInput: () => RenameInput2
+});
+import { SystemPart, ToolFailure } from "@opencode/ai";
+import { AbsolutePath } from "@opencode/schema/schema";
+import { Session } from "@opencode/schema/session";
+import { Effect, Schema } from "effect";
+var RenameInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to rename the current session." }),
+  title: Schema.String.check(Schema.isMinLength(1)).annotate({ description: "New session title." })
+});
+var RenameOutput = Schema.Struct({ sessionID: Session.ID, title: Schema.String });
+var MoveInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to move the current session." }),
+  directory: AbsolutePath.check(Schema.isMinLength(1)).annotate({
+    description: "Destination directory, relative to the target session's directory or absolute. Supports ~."
+  })
+});
+var MoveOutput = Schema.Struct({ sessionID: Session.ID, directory: AbsolutePath });
+var Plugin29 = {
+  id: "opencode.tools",
+  effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      event.system.push(SystemPart.make("When you create a worktree outside the current working directory and intend to use it as your primary working directory, consider using `execute` to call `tools.opencode.session_move` and make the worktree the session's working directory."));
+    }));
+    yield* ctx.tool.transform((draft) => {
+      draft.namespace({ name: "opencode", description: "OpenCode session and runtime tools." });
+      draft.add({
+        name: "session_rename",
+        description: "Rename a session, or omit sessionID to rename the current session. Use a short, specific title that summarizes the work being done.",
+        input: RenameInput2,
+        output: RenameOutput,
+        options: { namespace: "opencode", codemode: true },
+        execute: (input, context) => {
+          const sessionID = input.sessionID ?? context.sessionID;
+          const title = input.title.trim();
+          if (!title)
+            return Effect.fail(new ToolFailure({ message: "Session title must not be empty" }));
+          return ctx.session.rename({ sessionID, title }).pipe(Effect.as({
+            output: { sessionID, title },
+            content: `Renamed session ${sessionID} to ${title}.`
+          }), Effect.mapError((error) => new ToolFailure({ message: `Unable to rename session ${sessionID}`, error })));
+        }
+      });
+      draft.add({
+        name: "session_move",
+        description: "Move a session to another directory, or omit sessionID to move the current session. The current session moves at the next safe boundary; do not run destination-dependent tools in the same execute call.",
+        input: MoveInput2,
+        output: MoveOutput,
+        options: { namespace: "opencode", codemode: true, pinned: true },
+        execute: (input, context) => Effect.gen(function* () {
+          const sessionID = input.sessionID ?? context.sessionID;
+          yield* ctx.session.move({
+            sessionID,
+            directory: input.directory,
+            delivery: "steer"
+          });
+          return {
+            output: { sessionID, directory: input.directory },
+            content: `Moved session ${sessionID} to ${input.directory}.`
+          };
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to move session to ${input.directory}`, error })))
+      });
+    }).pipe(Effect.orDie);
+  })
+};
+
+export { RenameInput2, MoveInput2, Plugin29, exports_opencode };