@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-02dbfq60.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/integration/connection.ts
+var exports_connection = {};
+__export(exports_connection, {
+  IntegrationConnection: () => exports_connection,
+  Info: () => Info,
+  EnvInfo: () => EnvInfo,
+  CredentialInfo: () => CredentialInfo
+});
+import { Connection } from "@opencode-ai/schema/connection";
+var CredentialInfo = Connection.CredentialInfo;
+var EnvInfo = Connection.EnvInfo;
+var Info = Connection.Info;
+
+export { CredentialInfo, EnvInfo, Info, exports_connection };

package/dist/chunks/ripgrep-04kwjb53.js

@@ -0,0 +1,192 @@
+import {
+  which
+} from "./ripgrep-g7k9te92.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/shell/select.ts
+var exports_select = {};
+__export(exports_select, {
+  ps: () => ps,
+  preferred: () => preferred,
+  name: () => name,
+  login: () => login,
+  list: () => list,
+  gitbash: () => gitbash,
+  args: () => args,
+  acceptable: () => acceptable,
+  ShellSelect: () => exports_select,
+  Options: () => Options
+});
+import path from "path";
+import { readFile } from "fs/promises";
+import { statSync } from "fs";
+import { Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var META = {
+  bash: { login: true },
+  dash: { login: true },
+  fish: { deny: true, login: true },
+  ksh: { login: true },
+  nu: { deny: true },
+  powershell: { ps: true },
+  pwsh: { ps: true },
+  sh: { login: true },
+  zsh: { login: true }
+};
+var Options = Schema.Struct({
+  gitbash: Schema.optional(Schema.String)
+});
+function stat(file) {
+  return statSync(file, { throwIfNoEntry: false }) ?? undefined;
+}
+function findExecutable(name, bin) {
+  return which(name, undefined, bin);
+}
+function full(file, options, bin) {
+  if (process.platform !== "win32")
+    return file;
+  const shell = FSUtil.windowsPath(file);
+  if (path.win32.dirname(shell) !== ".") {
+    if (shell.startsWith("/") && name(shell) === "bash")
+      return gitbash(options, bin) || shell;
+    return shell;
+  }
+  if (name(shell) === "bash")
+    return gitbash(options, bin) || findExecutable(shell, bin) || shell;
+  return findExecutable(shell, bin) || shell;
+}
+function meta(file) {
+  return META[name(file)];
+}
+function ok(file) {
+  return meta(file)?.deny !== true;
+}
+function rooted(file) {
+  return path.isAbsolute(FSUtil.windowsPath(file));
+}
+function resolve(file, options, bin) {
+  const shell = full(file, options, bin);
+  if (rooted(shell)) {
+    if (stat(shell)?.isFile())
+      return shell;
+    return;
+  }
+  return findExecutable(shell, bin) ?? undefined;
+}
+function win(options, bin) {
+  return Array.from(new Set([
+    findExecutable("pwsh", bin),
+    findExecutable("powershell", bin),
+    gitbash(options, bin),
+    process.env.COMSPEC || "cmd.exe"
+  ].filter((item) => Boolean(item)).map((file) => full(file, options, bin))));
+}
+async function unix() {
+  const text = await readFile("/etc/shells", "utf8").catch(() => "");
+  if (text)
+    return Array.from(new Set(text.split(`
+`).filter((line) => line.trim() && !line.startsWith("#"))));
+  return ["/bin/bash", "/bin/zsh", "/bin/sh"];
+}
+function select(file, options, opts, bin) {
+  if (file && (!opts?.acceptable || ok(file))) {
+    const shell = resolve(file, options, bin);
+    if (shell)
+      return shell;
+  }
+  if (process.platform === "win32")
+    return win(options, bin)[0];
+  return fallback(bin);
+}
+function gitbash(options, bin) {
+  if (process.platform !== "win32")
+    return;
+  if (options?.gitbash)
+    return options.gitbash;
+  const git = findExecutable("git", bin);
+  if (!git)
+    return;
+  const file = path.join(git, "..", "..", "bin", "bash.exe");
+  if (stat(file)?.size)
+    return file;
+}
+function fallback(bin) {
+  if (process.platform === "darwin")
+    return "/bin/zsh";
+  const bash = findExecutable("bash", bin);
+  if (bash)
+    return bash;
+  return "/bin/sh";
+}
+function name(file) {
+  if (process.platform === "win32")
+    return path.win32.parse(FSUtil.windowsPath(file)).name.toLowerCase();
+  return path.basename(file).toLowerCase();
+}
+function login(file) {
+  return meta(file)?.login === true;
+}
+function ps(file) {
+  return meta(file)?.ps === true;
+}
+function info(file, options, bin) {
+  const item = full(file, options, bin);
+  const n = name(item);
+  return {
+    path: item,
+    name: resolve(n, options, bin) ? n : item,
+    acceptable: ok(item)
+  };
+}
+function args(file, command) {
+  const n = name(file);
+  if (n === "nu" || n === "fish")
+    return ["-c", command];
+  if (n === "zsh" || n === "bash")
+    return ["-c", command];
+  if (n === "cmd")
+    return ["/c", command];
+  if (ps(file))
+    return ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command];
+  return ["-c", command];
+}
+var defaultPreferred;
+var defaultAcceptable;
+function preferred(configShell, options, bin) {
+  if (configShell)
+    return select(configShell, options, undefined, bin);
+  if (options?.gitbash)
+    return select(process.env.SHELL, options, undefined, bin);
+  const cached = defaultPreferred;
+  if (cached && cached.bin === bin)
+    return cached.value;
+  const value = select(process.env.SHELL, undefined, undefined, bin) ?? fallback(bin);
+  defaultPreferred = { bin, value };
+  return value;
+}
+preferred.reset = () => {
+  defaultPreferred = undefined;
+};
+function acceptable(configShell, options, bin) {
+  if (configShell)
+    return select(configShell, options, { acceptable: true }, bin);
+  if (options?.gitbash)
+    return select(process.env.SHELL, options, { acceptable: true }, bin);
+  const cached = defaultAcceptable;
+  if (cached && cached.bin === bin)
+    return cached.value;
+  const value = select(process.env.SHELL, undefined, { acceptable: true }, bin) ?? fallback(bin);
+  defaultAcceptable = { bin, value };
+  return value;
+}
+acceptable.reset = () => {
+  defaultAcceptable = undefined;
+};
+async function list(options, bin) {
+  const shells = process.platform === "win32" ? win(options, bin) : await unix();
+  return shells.filter((shell) => resolve(shell, options, bin)).map((shell) => info(shell, options, bin));
+}
+
+export { Options, gitbash, name, login, ps, args, preferred, acceptable, list, exports_select };

package/dist/chunks/ripgrep-07vebpv5.js

@@ -0,0 +1,252 @@
+import {
+  exports_git as exports_git2
+} from "./ripgrep-0brv01ad.js";
+import {
+  DirectoryUnavailableError,
+  canonical
+} from "./ripgrep-8vhzxx5g.js";
+import {
+  Slug
+} from "./ripgrep-df3v2q6j.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  WorktreeTable
+} from "./ripgrep-mh28new4.js";
+import {
+  exports_schema
+} from "./ripgrep-8v47shgf.js";
+import {
+  ProjectTable
+} from "./ripgrep-88jbfw8z.js";
+import {
+  exports_git
+} from "./ripgrep-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  refreshNode: () => refreshNode,
+  refreshAfterBoot: () => refreshAfterBoot,
+  node: () => node,
+  Worktree: () => exports_worktree,
+  StrategyUnavailableError: () => StrategyUnavailableError,
+  StrategyID: () => StrategyID,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
+  Service: () => Service,
+  RemoveInput: () => RemoveInput,
+  RefreshResult: () => RefreshResult,
+  RefreshInput: () => RefreshInput,
+  ListInput: () => ListInput,
+  ListEntry: () => ListEntry,
+  List: () => List,
+  InvalidDirectoryError: () => InvalidDirectoryError,
+  Info: () => Info,
+  Event: () => Event,
+  DuplicateStrategyError: () => DuplicateStrategyError,
+  DirectoryUnavailableError: () => DirectoryUnavailableError,
+  DestinationExistsError: () => DestinationExistsError,
+  CreateInput: () => CreateInput
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Worktree } from "@opencode-ai/schema/worktree";
+var StrategyID = Worktree.StrategyID;
+var CreateInput = Worktree.CreateInput;
+var RemoveInput = Worktree.RemoveInput;
+var RefreshInput = Schema.Struct({
+  projectID: exports_schema.ID
+}).annotate({ identifier: "Worktree.RefreshInput" });
+var RefreshResult = Schema.Struct({
+  updated: Schema.Array(AbsolutePath),
+  removed: Schema.Array(AbsolutePath)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info = Worktree.Info;
+var ListInput = Worktree.ListInput;
+var List = Worktree.List;
+var ListEntry = Schema.Struct({
+  directory: AbsolutePath,
+  type: Schema.Literals(["root", "worktree"])
+}).annotate({ identifier: "Worktree.ListEntry" });
+
+class SourceDirectoryNotFoundError extends Schema.TaggedErrorClass()("Worktree.SourceDirectoryNotFoundError", { projectID: exports_schema.ID, directory: Schema.optional(AbsolutePath) }) {
+}
+
+class DestinationExistsError extends Schema.TaggedErrorClass()("Worktree.DestinationExistsError", { directory: AbsolutePath }) {
+}
+
+class InvalidDirectoryError extends Schema.TaggedErrorClass()("Worktree.InvalidDirectoryError", { directory: AbsolutePath }) {
+}
+
+class StrategyUnavailableError extends Schema.TaggedErrorClass()("Worktree.StrategyUnavailableError", { strategy: StrategyID }) {
+}
+
+class DuplicateStrategyError extends Schema.TaggedErrorClass()("Worktree.DuplicateStrategyError", { strategy: StrategyID }) {
+}
+var Event = Worktree.Event;
+
+class Service extends Context.Service()("@opencode/v2/Worktree") {
+}
+var refreshAfterBoot = Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const worktrees = yield* Service;
+  yield* Effect.gen(function* () {
+    yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
+    const result = yield* worktrees.refresh({ projectID: location.project.id });
+    yield* Effect.logInfo("worktree refresh done", {
+      projectID: location.project.id,
+      updated: result.updated,
+      removed: result.removed
+    });
+  }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const db = (yield* exports_database.Service).db;
+  const bus = yield* exports_bus.Service;
+  const changed = Effect.fnUntraced(function* (projectID, update) {
+    if (update)
+      yield* bus.publish(Event.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fn("Worktree.list")(function* (projectID) {
+      const rows = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(eq(WorktreeTable.project_id, projectID)).orderBy(desc(WorktreeTable.time_created), asc(WorktreeTable.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (projectID, directory) {
+      const row = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    primary: Effect.fnUntraced(function* (projectID) {
+      return yield* db.select({ directory: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, projectID)).get().pipe(Effect.orDie);
+    }),
+    create: Effect.fnUntraced(function* (input, tx) {
+      return (yield* (tx ?? db).insert(WorktreeTable).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
+        target: [WorktreeTable.project_id, WorktreeTable.directory],
+        set: { strategy: input.strategy ?? null },
+        setWhere: input.strategy ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy)) : isNotNull(WorktreeTable.strategy)
+      }).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    }),
+    remove: Effect.fnUntraced(function* (projectID, directory, tx) {
+      return (yield* (tx ?? db).delete(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    })
+  };
+  const registry = new Map;
+  const register = Effect.fn("Worktree.register")(function* (strategy) {
+    if (registry.has(strategy.id))
+      return yield* new DuplicateStrategyError({ strategy: strategy.id });
+    registry.set(strategy.id, strategy);
+  });
+  const gitStrategy = yield* exports_git2.make;
+  yield* register(gitStrategy).pipe(Effect.orDie);
+  const strategies = () => Array.from(registry.values());
+  const source = Effect.fnUntraced(function* (input, projectID) {
+    const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
+    if (!sourceDirectory)
+      return yield* new SourceDirectoryNotFoundError({ projectID });
+    const resolved = yield* canonical(fs, sourceDirectory);
+    if ((yield* ops.find(projectID, resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id) {
+    const found = registry.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input) {
+    const selected = yield* getStrategy(input.strategy);
+    const sourceDirectory = yield* source(input.from, input.projectID);
+    yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+    }
+    const result = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory
+    });
+    yield* changed(input.projectID, yield* ops.create({
+      projectID: input.projectID,
+      directory: result.directory,
+      strategy: input.strategy
+    }));
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    const worktreeDirectory = yield* canonical(fs, input.directory);
+    const stored = yield* ops.find(input.projectID, worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError({ directory: worktreeDirectory });
+    yield* (yield* getStrategy(StrategyID.make(stored.strategy))).remove({
+      directory: worktreeDirectory,
+      force: input.force
+    });
+    yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* (input) {
+    const stored = yield* ops.list(input.projectID);
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const sourceDirectories = checked.filter((item) => item.strategy === undefined && item.exists).map((item) => item.directory);
+    const discovered = yield* Effect.forEach(sourceDirectories, (sourceDirectory) => Effect.forEach(strategies(), (strategy) => strategy.list(sourceDirectory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])), Effect.map((items) => items.map((item) => ({
+      directory: item.directory,
+      strategy: item.type === "worktree" ? strategy.id : undefined
+    }))))), { concurrency: "unbounded" }).pipe(Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item])).values().toArray()));
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const result = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.forEach(discovered, (item) => ops.create({
+        projectID: input.projectID,
+        directory: item.directory,
+        strategy: item.strategy
+      }, tx)),
+      removed: Effect.forEach(removed, (directory) => ops.remove(input.projectID, directory, tx))
+    })).pipe(Effect.orDie);
+    const changes = {
+      updated: discovered.filter((_, index) => result.updated[index]).map((item) => item.directory),
+      removed: removed.filter((_, index) => result.removed[index])
+    };
+    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service.of({
+    register,
+    list: ops.list,
+    create,
+    remove,
+    refresh
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, exports_git.node, exports_bus.node, exports_database.node]
+});
+var refreshNode = makeLocationNode({
+  name: "worktree-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, exports_location.node]
+});
+
+export { StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Info, ListInput, List, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, InvalidDirectoryError, StrategyUnavailableError, DuplicateStrategyError, Event, Service, refreshAfterBoot, node, refreshNode, exports_worktree };

package/dist/chunks/ripgrep-09h352js.js

@@ -0,0 +1,68 @@
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  __export,
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/image.ts
+var exports_image = {};
+__export(exports_image, {
+  node: () => node,
+  SizeError: () => SizeError,
+  Service: () => Service,
+  ResizerUnavailableError: () => ResizerUnavailableError,
+  Image: () => exports_image,
+  DecodeError: () => DecodeError
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ResizerUnavailableError extends Schema.TaggedErrorClass()("Image.ResizerUnavailableError", {}) {
+}
+
+class DecodeError extends Schema.TaggedErrorClass()("Image.DecodeError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Image could not be decoded: ${this.resource}`;
+  }
+}
+
+class SizeError extends Schema.TaggedErrorClass()("Image.SizeError", {
+  resource: Schema.String,
+  width: Schema.Number,
+  height: Schema.Number,
+  bytes: Schema.Number,
+  maxWidth: Schema.Number,
+  maxHeight: Schema.Number,
+  maxBytes: Schema.Number
+}) {
+  get message() {
+    return `Image ${this.resource} is ${this.width}x${this.height} with base64 size ${this.bytes}, exceeding configured limits ${this.maxWidth}x${this.maxHeight}/${this.maxBytes} bytes`;
+  }
+}
+
+class Service extends Context.Service()("@opencode/Image") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const loadAdapter = yield* Effect.cached(Effect.tryPromise({
+    try: () => import("../image/photon.js"),
+    catch: () => new ResizerUnavailableError
+  }).pipe(Effect.flatMap((adapter) => adapter.make)));
+  const normalize = Effect.fn("Image.normalize")(function* (resource, content) {
+    const image = Object.assign({}, ...(yield* config.entries()).flatMap((entry) => entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : []));
+    const normalize2 = yield* loadAdapter;
+    return yield* normalize2(resource, content, {
+      autoResize: image.auto_resize ?? true,
+      maxWidth: image.max_width ?? 2000,
+      maxHeight: image.max_height ?? 2000,
+      maxBase64Bytes: image.max_base64_bytes ?? 5 * 1024 * 1024
+    });
+  });
+  return Service.of({ normalize });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_config.node] });
+
+export { ResizerUnavailableError, DecodeError, SizeError, Service, node, exports_image };

package/dist/chunks/ripgrep-0brv01ad.js

@@ -0,0 +1,49 @@
+import {
+  DirectoryUnavailableError,
+  canonical
+} from "./ripgrep-8vhzxx5g.js";
+import {
+  exports_git
+} from "./ripgrep-kcwh27nh.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/worktree/git.ts
+var exports_git2 = {};
+__export(exports_git2, {
+  make: () => make,
+  WorktreeGit: () => exports_git2
+});
+import { Effect } from "effect";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var make = Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  return {
+    id: Worktree.StrategyID.make("git"),
+    create: Effect.fn("Worktree.Git.create")(function* (input) {
+      const repository = yield* git.repo.discover(input.sourceDirectory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError({ directory: input.sourceDirectory });
+      yield* git.worktree.create({ repository, directory: input.directory });
+      return { directory: yield* canonical(fs, input.directory) };
+    }),
+    remove: Effect.fn("Worktree.Git.remove")(function* (input) {
+      const repository = yield* git.repo.discover(input.directory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError({ directory: input.directory });
+      yield* git.worktree.remove({ repository, directory: input.directory, force: input.force });
+    }),
+    list: Effect.fn("Worktree.Git.list")(function* (directory) {
+      const repository = yield* git.repo.discover(directory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError({ directory });
+      const entries = yield* git.worktree.list(repository);
+      return yield* Effect.forEach(entries, (entry) => canonical(fs, entry.directory).pipe(Effect.map((directory2) => ({ directory: directory2, type: entry.kind === "main" ? "root" : "worktree" })), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed(undefined)))).pipe(Effect.map((items) => items.filter((item) => item !== undefined)));
+    })
+  };
+});
+
+export { make, exports_git2 as exports_git };

package/dist/chunks/ripgrep-0cgt0xh2.js

@@ -0,0 +1,18 @@
+// src/github-copilot/chat/map-openai-compatible-finish-reason.ts
+function mapOpenAICompatibleFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
+export { mapOpenAICompatibleFinishReason };

package/dist/chunks/ripgrep-0dwyqmzq.js

@@ -0,0 +1,52 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/hooks.ts
+var exports_hooks = {};
+__export(exports_hooks, {
+  node: () => node,
+  Service: () => Service,
+  PluginHooks: () => exports_hooks
+});
+import { Context, Effect, Layer, Scope } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+
+class Service extends Context.Service()("@opencode/PluginHooks") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const callbacks = new Map;
+  const key = (domain, name) => `${domain}.${String(name)}`;
+  const register = Effect.fn("PluginHooks.register")(function* (domain, name, callback) {
+    const scope = yield* Scope.Scope;
+    const id = key(domain, name);
+    let active = true;
+    callbacks.set(id, [...callbacks.get(id) ?? [], callback]);
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      const next = (callbacks.get(id) ?? []).filter((item) => item !== callback);
+      if (next.length === 0)
+        callbacks.delete(id);
+      else
+        callbacks.set(id, next);
+    });
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  const trigger = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
+    for (const callback of callbacks.get(key(domain, name)) ?? []) {
+      const result = Reflect.apply(callback, undefined, [
+        event
+      ]);
+      yield* result;
+    }
+    return event;
+  });
+  const has = (domain, name) => Effect.sync(() => callbacks.has(key(domain, name)));
+  return Service.of({ has, register, trigger });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [] });
+
+export { Service, node, exports_hooks };

package/dist/chunks/ripgrep-0f48qthw.js

@@ -0,0 +1,32 @@
+// src/database/drizzle/sqlite-core/effect/count.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SQL, sql } from "drizzle-orm/sql/sql";
+function buildSQLiteEmbeddedCount(source, filters) {
+  return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
+}
+function buildSQLiteCount(source, filters) {
+  return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
+}
+
+class SQLiteEffectCountBuilder extends SQL {
+  static [entityKind] = "SQLiteEffectCountBuilder";
+  sql;
+  session;
+  constructor(params) {
+    super(buildSQLiteEmbeddedCount(params.source, params.filters).queryChunks);
+    this.session = params.session;
+    this.sql = buildSQLiteCount(params.source, params.filters);
+  }
+  execute(placeholderValues) {
+    return this.session.prepareQuery(this.session.dialect.sqlToQuery(this.sql), undefined, "all", (rows) => {
+      const v = rows[0]?.[0];
+      if (typeof v === "number")
+        return v;
+      return v ? Number(v) : 0;
+    }).execute(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectCountBuilder);
+
+export { SQLiteEffectCountBuilder };