@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-087amx3w.js

@@ -0,0 +1,261 @@
+import {
+  exports_hooks
+} from "./location-mutation-0dwyqmzq.js";
+import {
+  exports_select
+} from "./location-mutation-04kwjb53.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export,
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/shell.ts
+var exports_shell = {};
+__export(exports_shell, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Shell: () => exports_shell,
+  Service: () => Service,
+  NotFoundError: () => NotFoundError
+});
+import path from "path";
+import { Context, Deferred, Duration, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { produce } from "immer";
+import { Shell } from "@opencode-ai/schema/shell";
+import { AppProcess } from "@opencode-ai/util/process";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Global } from "@opencode-ai/util/global";
+class NotFoundError extends Schema.TaggedErrorClass()("Shell.NotFoundError", {
+  id: Shell.ID
+}) {
+}
+var EXITED_LIMIT = 25;
+
+class Service extends Context.Service()("@opencode/Shell") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const location = yield* exports_location.Service;
+  const config = yield* exports_config.Service;
+  const global = yield* Global.Service;
+  const environment = yield* exports_environment.Service;
+  const hooks = yield* exports_hooks.Service;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const sessions = new Map;
+  const exitOrder = [];
+  const outputDir = path.join(global.data, "shell", location.project.id);
+  const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"));
+  const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"));
+  yield* Effect.promise(() => mkdir(outputDir, { recursive: true }));
+  yield* Effect.addFinalizer(() => Effect.gen(function* () {
+    for (const session of sessions.values()) {
+      if (session.timeoutFiber)
+        yield* Fiber.interrupt(session.timeoutFiber);
+      yield* Deferred.fail(session.done, new NotFoundError({ id: Shell.ID.make(session.info.id) }));
+    }
+    sessions.clear();
+    exitOrder.length = 0;
+  }));
+  const require2 = Effect.fn("Shell.require")(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return yield* new NotFoundError({ id });
+    return session;
+  });
+  const removeSession = Effect.fnUntraced(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return;
+    sessions.delete(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    if (session.timeoutFiber)
+      yield* Fiber.interrupt(session.timeoutFiber);
+    yield* Deferred.fail(session.done, new NotFoundError({ id }));
+    yield* Effect.promise(() => unlink(session.file).catch(() => {}));
+    yield* bus.publish(Shell.Event.Deleted, { id });
+  });
+  const remove = Effect.fn("Shell.remove")(function* (id) {
+    yield* require2(id);
+    yield* removeSession(id);
+  });
+  const list = Effect.fn("Shell.list")(function* () {
+    return Array.from(sessions.values()).filter((session) => session.info.status === "running").map((session) => session.info);
+  });
+  const get = Effect.fn("Shell.get")(function* (id) {
+    return (yield* require2(id)).info;
+  });
+  const wait = Effect.fn("Shell.wait")(function* (id) {
+    return yield* Deferred.await((yield* require2(id)).done);
+  });
+  const timeout = Effect.fn("Shell.timeout")(function* (id, duration) {
+    const session = yield* require2(id);
+    if (session.info.status !== "running" || !session.timeout)
+      return session.info;
+    yield* session.timeout(duration);
+    return session.info;
+  });
+  const resolve = () => config.entries().pipe(Effect.map((entries) => exports_select.preferred(exports_config.latest(entries, "shell"), options, global.bin)));
+  const name = () => resolve().pipe(Effect.map(exports_select.name));
+  const output = Effect.fn("Shell.output")(function* (id, input) {
+    const session = yield* require2(id);
+    const cursor = input?.cursor ?? 0;
+    const limit = input?.limit ?? 65536;
+    if (cursor >= session.size)
+      return { output: "", cursor: session.size, size: session.size, truncated: false };
+    const start = Math.max(0, cursor);
+    const length = Math.min(limit, session.size - start);
+    const buffer = Buffer.alloc(length);
+    const bytesRead = yield* Effect.promise(() => new Promise((resolve2) => {
+      const stream = createReadStream(session.file, { start, end: start + length - 1 });
+      let offset = 0;
+      stream.on("data", (chunk) => {
+        const bytes = Buffer.from(chunk);
+        bytes.copy(buffer, offset);
+        offset += bytes.length;
+      });
+      stream.on("end", () => resolve2(offset));
+      stream.on("error", () => resolve2(0));
+    }));
+    return {
+      output: buffer.subarray(0, bytesRead).toString("utf8"),
+      cursor: start + bytesRead,
+      size: session.size,
+      truncated: false
+    };
+  });
+  const create = Effect.fn("Shell.create")(function* (input, before) {
+    const invocation = {
+      command: input.command,
+      cwd: input.cwd ?? location.directory,
+      timeout: input.timeout,
+      shell: yield* resolve(),
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        OPENCODE_TERMINAL: "1"
+      }
+    };
+    yield* hooks.trigger("shell", "create.before", invocation);
+    if (before)
+      yield* before(invocation);
+    const id = Shell.ID.ascending();
+    const args = exports_select.args(invocation.shell, invocation.command);
+    const file = path.join(outputDir, `${id}.out`);
+    const info = {
+      id,
+      status: "running",
+      command: invocation.command,
+      cwd: invocation.cwd,
+      shell: invocation.shell,
+      file,
+      metadata: input.metadata ?? {},
+      time: { started: Date.now() }
+    };
+    const ready = Deferred.makeUnsafe();
+    runFork(Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(invocation.shell, args, {
+        cwd: invocation.cwd,
+        env: invocation.env,
+        stdin: "ignore",
+        detached: process.platform !== "win32",
+        forceKillAfter: Duration.seconds(3)
+      })).pipe(Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })));
+      const session2 = {
+        info: produce(info, (draft) => {
+          draft.pid = handle.pid;
+        }),
+        file,
+        size: 0,
+        done: Deferred.makeUnsafe()
+      };
+      sessions.set(id, session2);
+      const stream = createWriteStream(file);
+      const outputDone = Deferred.makeUnsafe();
+      const pump = handle.all.pipe(Stream.runForEach((chunk) => Effect.sync(() => {
+        stream.write(chunk);
+        session2.size += chunk.length;
+      })));
+      runFork(Effect.gen(function* () {
+        yield* pump.pipe(Effect.catch(() => Effect.void));
+        yield* Effect.promise(() => new Promise((resolve2) => {
+          stream.end(() => resolve2());
+        }));
+        yield* Deferred.succeed(outputDone, undefined);
+      }).pipe(Effect.catch(() => Deferred.succeed(outputDone, undefined))));
+      yield* Effect.promise(() => new Promise((resolve2) => {
+        stream.once("open", () => resolve2());
+        stream.once("error", () => resolve2());
+      }));
+      const finish = (status, exit, beforeWait = Effect.void) => Effect.gen(function* () {
+        if (session2.info.status !== "running")
+          return;
+        session2.info = produce(session2.info, (draft) => {
+          draft.status = status;
+          if (exit !== undefined)
+            draft.exit = exit;
+          draft.time.completed = Date.now();
+        });
+        yield* beforeWait;
+        yield* Deferred.await(outputDone);
+        yield* Deferred.succeed(session2.done, session2.info);
+        yield* bus.publish(Shell.Event.Exited, {
+          id,
+          ...exit !== undefined ? { exit } : {},
+          status
+        });
+        exitOrder.push(id);
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeSession(Shell.ID.make(oldest));
+        }
+        if (session2.timeoutFiber)
+          yield* Fiber.interrupt(session2.timeoutFiber);
+      });
+      session2.timeout = (duration) => Effect.gen(function* () {
+        if (session2.timeoutFiber)
+          yield* Fiber.interrupt(session2.timeoutFiber);
+        session2.timeoutFiber = undefined;
+        if (duration === 0 || session2.info.status !== "running")
+          return;
+        session2.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill().pipe(Effect.catch(() => Effect.void)))), Effect.catch(() => Effect.void)));
+      });
+      yield* session2.timeout(invocation.timeout);
+      runFork(handle.exitCode.pipe(Effect.flatMap((code) => finish("exited", code)), Effect.catch(() => Effect.void)));
+      yield* bus.publish(Shell.Event.Created, { info });
+      yield* Deferred.succeed(ready, session2);
+      yield* Deferred.await(session2.done).pipe(Effect.catch(() => Effect.void));
+    })).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))));
+    const session = yield* Deferred.await(ready);
+    return session.info;
+  });
+  return Service.of({ name, create, list, get, wait, timeout, output, remove });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_bus.node, exports_location.node, exports_config.node, Global.node, exports_environment.node, exports_hooks.node]
+  });
+}
+var node = configured();
+
+export { NotFoundError, Service, layer, configured, node, exports_shell };

package/dist/chunks/location-mutation-0brv01ad.js

@@ -0,0 +1,49 @@
+import {
+  DirectoryUnavailableError,
+  canonical
+} from "./location-mutation-8vhzxx5g.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  __export
+} from "./location-mutation-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/location-mutation-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/location-mutation-0dwyqmzq.js

@@ -0,0 +1,52 @@
+import {
+  __export
+} from "./location-mutation-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/location-mutation-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 };