@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-qszfca0d.js

@@ -0,0 +1,124 @@
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_filesystem
+} from "./ripgrep-jzf304yt.js";
+import {
+  exports_ripgrep
+} from "./ripgrep-3kxbn56b.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  toModelContent: () => toModelContent,
+  name: () => name,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  GlobTool: () => exports_glob
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name = "glob";
+var Input = Schema.Struct({
+  pattern: exports_filesystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath).annotate({
+    description: "Directory to search. Defaults to the current working directory."
+  }),
+  limit: exports_filesystem.GlobInput.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  })
+});
+var Output = Schema.Array(exports_filesystem.Entry);
+var toModelContent = (entries, truncated = false) => {
+  const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin = {
+  id: "opencode.tool.glob",
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
+    const environment = yield* exports_environment.Service;
+    const ripgrep = yield* exports_ripgrep.Service;
+    const location = yield* exports_location.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" });
+        const external = target.externalDirectory;
+        if (external)
+          yield* permission.assert({
+            ...exports_location_mutation.externalDirectoryPermission(external),
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+        yield* permission.assert({
+          action: name,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: searchPath ?? ".",
+            path: searchPath,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const type = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        if (type !== "directory")
+          return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
+        const root = target.absolute;
+        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const entries = yield* ripgrep.glob({
+          cwd: root,
+          pattern: input.pattern,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((entry) => exports_filesystem.Entry.make({
+          ...entry,
+          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path)))
+        }))));
+        return { entries: entries.slice(0, limit), truncated: entries.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.entries,
+        content: toModelContent(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        metadata: { count: result.entries.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, toModelContent, Plugin, exports_glob };

package/dist/chunks/ripgrep-qvqgqyrp.js

@@ -0,0 +1,127 @@
+import {
+  make
+} from "./ripgrep-706a4azd.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/formatter.ts
+var exports_formatter = {};
+__export(exports_formatter, {
+  node: () => node,
+  Service: () => Service,
+  Formatter: () => exports_formatter
+});
+import { Context, Effect, Layer } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Npm } from "@opencode-ai/util/npm";
+import { AppProcess } from "@opencode-ai/util/process";
+import { Global } from "@opencode-ai/util/global";
+class Service extends Context.Service()("@opencode/v2/Formatter") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const npm = yield* Npm.Service;
+  const processes = yield* AppProcess.Service;
+  const global = yield* Global.Service;
+  const commands = new Map;
+  let formatters = [];
+  const load = yield* Effect.cached(Effect.gen(function* () {
+    const configured = exports_config.latest(yield* config.entries(), "formatter");
+    if (!configured) {
+      yield* Effect.logInfo("all formatters are disabled");
+      return;
+    }
+    const builtIns = make({
+      directory: location.directory,
+      worktree: location.project.directory,
+      fs,
+      npm,
+      processes,
+      bin: global.bin
+    });
+    formatters = builtIns;
+    if (configured === true)
+      return;
+    for (const [name, entry] of Object.entries(configured)) {
+      const index = formatters.findIndex((formatter2) => formatter2.name === name);
+      if (entry.disabled) {
+        if (index !== -1)
+          formatters.splice(index, 1);
+        continue;
+      }
+      const builtIn = builtIns.find((formatter2) => formatter2.name === name);
+      const formatter = {
+        name,
+        extensions: entry.extensions ?? builtIn?.extensions ?? [],
+        environment: { ...builtIn?.environment, ...entry.environment },
+        enabled: builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false)
+      };
+      if (index === -1)
+        formatters.push(formatter);
+      else
+        formatters[index] = formatter;
+    }
+  }).pipe(Effect.withSpan("Formatter.load")));
+  const command = Effect.fnUntraced(function* (formatter) {
+    const cached = commands.get(formatter.name);
+    if (cached !== undefined)
+      return cached;
+    const result = yield* formatter.enabled;
+    if (result !== false)
+      commands.set(formatter.name, result);
+    return result;
+  });
+  const file = Effect.fn("Formatter.file")(function* (filepath) {
+    yield* load;
+    const matching = formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)));
+    for (const formatter of matching) {
+      const enabled = yield* command(formatter);
+      if (enabled === false)
+        continue;
+      const cmd = enabled.map((argument) => argument.replace("$FILE", filepath));
+      yield* Effect.logInfo("formatting file", { file: filepath, command: cmd });
+      const result = yield* processes.run(ChildProcess.make(cmd[0], cmd.slice(1), {
+        cwd: location.directory,
+        env: formatter.environment,
+        extendEnv: true,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore"
+      })).pipe(Effect.catch((error) => Effect.logError("failed to format file", {
+        file: filepath,
+        command: cmd,
+        error: error.message
+      }).pipe(Effect.as(undefined))));
+      if (!result)
+        continue;
+      if (result.exitCode === 0)
+        return true;
+      yield* Effect.logError("formatter exited unsuccessfully", {
+        file: filepath,
+        command: cmd,
+        exitCode: result.exitCode
+      });
+    }
+    return false;
+  });
+  return Service.of({ file });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, exports_location.node, Npm.node, AppProcess.node, Global.node]
+});
+
+export { Service, node, exports_formatter };

package/dist/chunks/ripgrep-r3k9abhd.js

@@ -0,0 +1,34 @@
+import {
+  PositiveInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/attachment.ts
+var exports_attachment = {};
+__export(exports_attachment, {
+  Info: () => Info,
+  Image: () => Image,
+  ConfigAttachmentV1: () => exports_attachment
+});
+import { Schema } from "effect";
+var Image = Schema.Struct({
+  auto_resize: Schema.optional(Schema.Boolean).annotate({
+    description: "Resize images before sending them to the model when they exceed configured limits (default: true)"
+  }),
+  max_width: Schema.optional(PositiveInt).annotate({
+    description: "Maximum image width before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_height: Schema.optional(PositiveInt).annotate({
+    description: "Maximum image height before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_base64_bytes: Schema.optional(PositiveInt).annotate({
+    description: "Maximum base64 payload bytes for an image attachment (default: 5242880)"
+  })
+}).annotate({ identifier: "ImageAttachmentConfig" });
+var Info = Schema.Struct({
+  image: Schema.optional(Image).annotate({ description: "Image attachment configuration" })
+}).annotate({ identifier: "AttachmentConfig" });
+
+export { Image, Info, exports_attachment };

package/dist/chunks/ripgrep-r4h6gatx.js

@@ -0,0 +1,90 @@
+import {
+  InstructionEntryTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/instruction-entry.ts
+var exports_instruction_entry = {};
+__export(exports_instruction_entry, {
+  node: () => node,
+  ValueTooLargeError: () => ValueTooLargeError,
+  Service: () => Service,
+  MaxValueBytes: () => MaxValueBytes,
+  Key: () => Key,
+  InstructionEntry: () => exports_instruction_entry,
+  Info: () => Info
+});
+import { and, asc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { InstructionEntry } from "@opencode-ai/schema/instruction-entry";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var Key = InstructionEntry.Key;
+var Info = InstructionEntry.Info;
+var MaxValueBytes = InstructionEntry.MaxValueBytes;
+var ValueTooLargeError = InstructionEntry.ValueTooLargeError;
+
+class Service extends Context.Service()("@opencode/InstructionEntry") {
+}
+var renderValue = (value) => typeof value === "string" ? value : JSON.stringify(value, null, 2);
+var renderBlock = (key, value) => [`<context key="${key}">`, renderValue(value), "</context>"].join(`
+`);
+var source = (entry) => exports_instructions.make({
+  key: exports_instructions.Key.make(`api/${entry.key}`),
+  codec: Schema.toCodecJson(Schema.Json),
+  read: Effect.succeed(entry.removed ? exports_instructions.removed : entry.value),
+  render: {
+    initial: (value) => renderBlock(entry.key, value),
+    changed: (_previous, value) => [
+      `The context under "${entry.key}" changed and supersedes the previous value:`,
+      renderBlock(entry.key, value)
+    ].join(`
+`),
+    removed: () => `The context under "${entry.key}" no longer applies. Disregard it.`
+  }
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const rows = Effect.fnUntraced(function* (sessionID, includeRemoved) {
+    return yield* db.select({
+      key: InstructionEntryTable.key,
+      value: InstructionEntryTable.value,
+      removed: InstructionEntryTable.removed
+    }).from(InstructionEntryTable).where(and(eq(InstructionEntryTable.session_id, sessionID), includeRemoved ? undefined : eq(InstructionEntryTable.removed, false))).orderBy(asc(InstructionEntryTable.key)).all().pipe(Effect.orDie);
+  });
+  const list = Effect.fn("InstructionEntry.list")(function* (sessionID) {
+    return (yield* rows(sessionID, false)).map((row) => ({ key: row.key, value: row.value }));
+  });
+  const put = Effect.fn("InstructionEntry.put")(function* (input) {
+    const actualBytes = Buffer.byteLength(JSON.stringify(input.value), "utf8");
+    if (actualBytes > MaxValueBytes)
+      yield* new ValueTooLargeError({
+        actualBytes,
+        maxBytes: MaxValueBytes,
+        message: `Instruction entry value is ${actualBytes} bytes; the limit is ${MaxValueBytes} bytes`
+      });
+    const changed = input.value === null ? isNotNull(InstructionEntryTable.value) : or(isNull(InstructionEntryTable.value), ne(InstructionEntryTable.value, input.value));
+    yield* db.insert(InstructionEntryTable).values({ session_id: input.sessionID, key: input.key, value: input.value, removed: false }).onConflictDoUpdate({
+      target: [InstructionEntryTable.session_id, InstructionEntryTable.key],
+      set: { value: input.value, removed: false, time_updated: Date.now() },
+      setWhere: or(eq(InstructionEntryTable.removed, true), changed)
+    }).run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("InstructionEntry.remove")(function* (input) {
+    yield* db.update(InstructionEntryTable).set({ value: null, removed: true, time_updated: Date.now() }).where(and(eq(InstructionEntryTable.session_id, input.sessionID), eq(InstructionEntryTable.key, input.key), eq(InstructionEntryTable.removed, false))).run().pipe(Effect.orDie);
+  });
+  const load = Effect.fn("InstructionEntry.load")(function* (sessionID) {
+    return exports_instructions.combine((yield* rows(sessionID, true)).map(source));
+  });
+  return Service.of({ list, put, remove, load });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { Key, Info, MaxValueBytes, ValueTooLargeError, Service, node, exports_instruction_entry };

package/dist/chunks/ripgrep-r8f4w671.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/openai-error.ts
+import { z } from "zod/v4";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+var openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var openaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+export { openaiErrorDataSchema, openaiFailedResponseHandler };

package/dist/chunks/ripgrep-rdfev9jy.js

@@ -0,0 +1,12 @@
+// src/filesystem/fff.ts
+function bind(backend, unavailable = "fff unavailable") {
+  return {
+    available: () => backend?.isAvailable() ?? false,
+    create: (options) => backend?.create(options) ?? {
+      ok: false,
+      error: unavailable
+    }
+  };
+}
+
+export { bind };