@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-39fveamk.js

@@ -0,0 +1,271 @@
+import {
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./repository-3w5fmr99.js";
+import {
+  create2,
+  catalog2
+} from "./repository-r9mregkx.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  Service80,
+  node85
+} from "./repository-drknmmyh.js";
+import {
+  Service62,
+  node66
+} from "./repository-mgx963cj.js";
+import {
+  match2
+} from "./repository-y1fvbwt7.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
+  Error: () => Error3,
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service41,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node46
+});
+import { CallID as CallID2, Content as Content3, Error as Error3, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode/schema/tool";
+import { ToolDefinition } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service41 extends Context.Service()("@opencode/Tool") {
+}
+var layer = Layer.effect(Service41, Effect.gen(function* () {
+  const hooks = yield* Service62;
+  const image = yield* Service80;
+  const normalizeImages = Effect.fnUntraced(function* (content) {
+    const normalized = yield* Effect.forEach(content, (item) => {
+      if (item.type !== "file" || !item.mime.startsWith("image/"))
+        return Effect.succeed(item);
+      const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1];
+      if (base64 === undefined)
+        return Effect.succeed(item);
+      const resource = item.name ?? `${item.mime} tool output`;
+      return image.normalize(resource, { uri: resource, content: base64, encoding: "base64", mime: item.mime }).pipe(Effect.map((result) => ({
+        ...item,
+        uri: `data:${result.mime};base64,${result.content}`,
+        mime: result.mime
+      })), Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(item)), Effect.catchTag("Image.DecodeError", () => Effect.succeed("decode")), Effect.catchTag("Image.SizeError", () => Effect.succeed("size")));
+    });
+    const note = (reason, text) => {
+      const count = normalized.filter((item) => item === reason).length;
+      if (count === 0)
+        return [];
+      return [{ type: "text", text: `[${count} image${count === 1 ? "" : "s"} omitted: ${text}]` }];
+    };
+    return [
+      ...normalized.filter((item) => typeof item !== "string"),
+      ...note("decode", "could not be decoded."),
+      ...note("size", "could not be resized below the image size limit.")
+    ];
+  });
+  const beforeExecute = (name, input, context) => hooks.trigger("tool", "execute.before", {
+    tool: name,
+    sessionID: context.sessionID,
+    agent: context.agent,
+    messageID: context.messageID,
+    id: context.id,
+    input
+  });
+  const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const base = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input
+    };
+    if ("failure" in execution) {
+      const afterEvent = {
+        ...base,
+        status: "error",
+        error: execution.failure
+      };
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
+    }
+    const afterEvent = {
+      ...base,
+      status: "completed",
+      result: {
+        ...execution.value.output === undefined ? {} : { output: execution.value.output },
+        content: execution.value.content,
+        ...execution.value.metadata === undefined ? {} : { metadata: execution.value.metadata }
+      }
+    };
+    yield* hooks.trigger("tool", "execute.after", afterEvent);
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
+    return {
+      ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
+      content: afterContent,
+      ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
+    };
+  });
+  const state = create3({
+    name: "tool",
+    initial: () => ({
+      tools: new Map,
+      namespaces: new Map,
+      errors: []
+    }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.tools.values()),
+      get: (id) => editor.tools.get(id),
+      namespace: (namespace) => {
+        const error = namespaceError(namespace.name);
+        if (error) {
+          editor.errors.push({ kind: "namespace", name: namespace.name, namespace: namespace.name, error });
+          return;
+        }
+        editor.namespaces.set(namespace.name, { ...namespace });
+      },
+      add: (tool) => {
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        const id = effectiveName2(tool);
+        editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
+      },
+      update: (id, update) => {
+        const current = editor.tools.get(id);
+        if (!current)
+          return;
+        const tool = { ...current, options: current.options && { ...current.options } };
+        update(tool);
+        tool.name = current.name;
+        tool.id = id;
+        if (tool.options?.namespace !== current.options?.namespace)
+          tool.options = { ...tool.options, namespace: current.options?.namespace };
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        editor.tools.set(id, tool);
+      },
+      remove: (id) => {
+        editor.tools.delete(id);
+      }
+    }),
+    notify: (value) => Effect.forEach(value.errors, ({ kind, name, namespace, error }) => Effect.logError(`Skipping invalid ${kind} registration`, {
+      name,
+      namespace,
+      error: error.message
+    }), { discard: true })
+  });
+  return Service41.of({
+    transform: state.transform,
+    reload: state.reload,
+    snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
+      const active = new Map;
+      const rules = permissions ?? [];
+      for (const [name, tool] of state.get().tools) {
+        if (whollyDisabled(tool.options?.permission ?? name, rules))
+          continue;
+        active.set(name, tool);
+      }
+      const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
+      const codeModeTools = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const namespaces = state.get().namespaces;
+      const codeModeInventory = { tools: codeModeTools, namespaces };
+      const codeModeEnabled = !whollyDisabled("execute", rules);
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
+      return {
+        ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
+        definitions: [
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
+        ],
+        execute: Effect.fnUntraced(function* (input) {
+          const context = {
+            sessionID: input.sessionID,
+            agent: input.agent,
+            messageID: input.messageID,
+            id: Tool.CallID.make(input.call.id),
+            progress: input.progress ?? (() => Effect.void)
+          };
+          const event = yield* beforeExecute(input.call.name, input.call.input, context);
+          const requested = input.definitions?.get(event.tool);
+          if (!requested && input.definitions && (direct.has(event.tool) || codeModeTool?.name === event.tool))
+            return yield* new Tool.Error({ message: `Tool is not available for this request: ${event.tool}` });
+          const name = requested?.name ?? event.tool;
+          if (name === "execute" && codeModeTool)
+            return yield* executeTool(codeModeTool, name, event.input, context);
+          const tool = direct.get(name);
+          if (tool)
+            return yield* executeTool(tool, name, event.input, context);
+          return yield* new Tool.Error({ message: `Unknown tool: ${name}` });
+        })
+      };
+    }))
+  });
+}));
+var whollyDisabled = (action, rules) => {
+  const rule = rules.findLast((rule) => match2(action, rule.action));
+  return rule?.resource === "*" && rule.effect === "deny";
+};
+var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
+function schemaMakeError(error) {
+  if (error instanceof Error && SchemaIssue.isIssue(error.cause))
+    return formatSchemaIssue(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function registrationError(tool) {
+  const namespace = tool.options?.namespace;
+  if (namespace !== undefined) {
+    const error = namespaceError(namespace);
+    if (error)
+      return error;
+  }
+  const name = normalizedName2(tool);
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
+  if (tool.options?.codemode === false && id === "execute")
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+  const result = Result.try({
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+  });
+  return Result.isFailure(result) ? result.failure : undefined;
+}
+function namespaceError(name) {
+  if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
+    return;
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+}
+var node46 = makeLocationNode({
+  service: Service41,
+  layer,
+  deps: [node66, node85]
+});
+
+export { RegistrationError2, Service41, node46, exports_tool, CallID2, Content3, Error3, FileContent3, TextContent2 };

package/dist/chunks/repository-3asan66x.js

@@ -0,0 +1,19 @@
+// src/github-copilot/responses/map-openai-responses-finish-reason.ts
+function mapOpenAIResponseFinishReason2({
+  finishReason,
+  hasFunctionCall
+}) {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasFunctionCall ? "tool-calls" : "other";
+  }
+}
+
+export { mapOpenAIResponseFinishReason2 };

package/dist/chunks/repository-3hepkmqq.js

@@ -0,0 +1,13 @@
+import {
+  Timestamps2
+} from "./repository-qfa1cgps.js";
+
+// src/kv/sql.ts
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+var KVTable2 = sqliteTable("kv", {
+  key: text().primaryKey(),
+  value: text({ mode: "json" }).$type().notNull(),
+  ...Timestamps2
+});
+
+export { KVTable2 };

package/dist/chunks/repository-3ke3s58r.js

@@ -0,0 +1,213 @@
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  which2
+} from "./repository-qaymkmh1.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/shell/select.ts
+var exports_select = {};
+__export(exports_select, {
+  Options: () => Options10,
+  Service: () => Service57,
+  ShellSelect: () => exports_select,
+  args: () => args2,
+  configured: () => configured10,
+  environment: () => environment2,
+  gitbash: () => gitbash2,
+  list: () => list4,
+  login: () => login2,
+  name: () => name15,
+  node: () => node61,
+  ps: () => ps2,
+  resolve: () => resolve3
+});
+import path from "path";
+import { readFile } from "fs/promises";
+import { statSync } from "fs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+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 Options10 = Schema.Struct({
+  gitbash: Schema.optional(Schema.String)
+});
+
+class Service57 extends Context.Service()("@opencode/ShellSelect") {
+}
+function stat(file) {
+  return statSync(file, { throwIfNoEntry: false }) ?? undefined;
+}
+function findExecutable(name, bin) {
+  return which2(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("/") && name15(shell) === "bash")
+      return gitbash2(options, bin) || shell;
+    return shell;
+  }
+  if (name15(shell) === "bash")
+    return gitbash2(options, bin) || findExecutable(shell, bin) || shell;
+  return findExecutable(shell, bin) || shell;
+}
+function meta(file) {
+  return META[name15(file)];
+}
+function compatible(file) {
+  return meta(file)?.deny !== true;
+}
+function rooted(file) {
+  return path.isAbsolute(FSUtil.windowsPath(file));
+}
+function executable(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),
+    gitbash2(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?.compatible || compatible(file))) {
+    const shell = executable(file, options, bin);
+    if (shell)
+      return shell;
+  }
+  if (process.platform === "win32")
+    return win(options, bin)[0];
+  return fallback(bin);
+}
+function gitbash2(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 name15(file) {
+  if (process.platform === "win32")
+    return path.win32.parse(FSUtil.windowsPath(file)).name.toLowerCase();
+  return path.basename(file).toLowerCase();
+}
+function login2(file) {
+  return meta(file)?.login === true;
+}
+function ps2(file) {
+  return meta(file)?.ps === true;
+}
+function info(file, options, bin) {
+  const item = full(file, options, bin);
+  const n = name15(item);
+  return {
+    path: item,
+    name: executable(n, options, bin) ? n : item,
+    acceptable: compatible(item)
+  };
+}
+function args2(file, command) {
+  const n = name15(file);
+  if (n === "cmd")
+    return ["/c", command];
+  if (ps2(file))
+    return ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command];
+  return ["-c", command];
+}
+function environment2(bin, filter) {
+  return select(process.env.SHELL, undefined, filter, bin) ?? fallback(bin);
+}
+var defaultConfigured;
+var defaultCompatible;
+function resolve3(input, configShell, options, bin) {
+  const filter = input.priority === "compat" ? { compatible: true } : undefined;
+  if (configShell)
+    return select(configShell, options, filter, bin);
+  if (options?.gitbash)
+    return select(process.env.SHELL, options, filter, bin);
+  const cached = input.priority === "compat" ? defaultCompatible : defaultConfigured;
+  if (cached && cached.bin === bin)
+    return cached.value;
+  const value = environment2(bin, filter);
+  if (input.priority === "compat")
+    defaultCompatible = { bin, value };
+  if (input.priority === "config")
+    defaultConfigured = { bin, value };
+  return value;
+}
+resolve3.reset = () => {
+  defaultConfigured = undefined;
+  defaultCompatible = undefined;
+};
+async function list4(options, bin) {
+  const shells = process.platform === "win32" ? win(options, bin) : await unix();
+  return shells.filter((shell) => executable(shell, options, bin)).map((shell) => info(shell, options, bin));
+}
+var layer = (options) => Layer.effect(Service57, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const state = create3({
+    name: "shell-select",
+    initial: () => ({}),
+    editor: (editor) => ({
+      configure: (shell) => {
+        editor.shell = shell;
+      }
+    })
+  });
+  return Service57.of({
+    transform: state.transform,
+    reload: state.reload,
+    resolve: (input) => Effect.sync(() => resolve3(input, state.get().shell, options, global.bin))
+  });
+}));
+function configured10(options) {
+  return makeLocationNode({ service: Service57, layer: layer(options), deps: [Global.node] });
+}
+var node61 = configured10();
+
+export { Options10, Service57, gitbash2, name15, login2, ps2, args2, environment2, resolve3, list4, configured10, node61, exports_select };

package/dist/chunks/repository-3mdgf1e2.js

@@ -0,0 +1,76 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2,
+  typeFollowing2
+} from "./repository-2a5m3afh.js";
+import {
+  execDefaults2
+} from "./repository-1dazxqgg.js";
+import {
+  makeLocalDriver2
+} from "./repository-b6gygkdw.js";
+import {
+  makeMemoryDriver2
+} from "./repository-aaet6srn.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service76,
+  node80
+} from "./repository-36564s8r.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/environment/environment.ts
+var exports_environment2 = {};
+__export(exports_environment2, {
+  EnvironmentService: () => exports_environment2,
+  Service: () => Service65,
+  node: () => node69
+});
+import { CrossSpawnSpawner } from "@opencode/util/cross-spawn-spawner";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+
+// src/environment/index.ts
+var exports_environment3 = {};
+__export(exports_environment3, {
+  Environment: () => exports_environment3,
+  Failed: () => Failed2,
+  NotFound: () => NotFound2,
+  Service: () => Service65,
+  WrongKind: () => WrongKind2,
+  execDefaults: () => execDefaults2,
+  makeFiles: () => makeFiles2,
+  makeLocalDriver: () => makeLocalDriver2,
+  makeMemoryDriver: () => makeMemoryDriver2,
+  node: () => node69,
+  typeFollowing: () => typeFollowing2
+});
+var makeFiles2 = (driver) => ({
+  ...execDefaults2(driver.spawner),
+  ...driver.overrides
+});
+
+// src/environment/environment.ts
+class Service65 extends Context.Service()("@opencode/Environment") {
+}
+var layer = Layer.effect(Service65, Effect.gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const location = yield* Service66;
+  const workspace = yield* Service76;
+  const driver = location.workspaceID ? yield* workspace.connect(location.workspaceID).pipe(Effect.mapError((cause) => new Error(`Failed to bind Environment to workspace ${location.workspaceID}`, { cause })), Effect.orDie) : makeLocalDriver2(spawner);
+  return Service65.of({ files: makeFiles2(driver), spawner: driver.spawner });
+}));
+var node69 = makeLocationNode({
+  service: Service65,
+  layer,
+  deps: [CrossSpawnSpawner.node, node70, node80]
+});
+
+export { Service65, node69, exports_environment2, makeFiles2, exports_environment3 };