@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-5a5ch9ts.js

@@ -0,0 +1,31 @@
+// src/github-copilot/responses/tool/code-interpreter.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var codeInterpreterInputSchema = z.object({
+  code: z.string().nullish(),
+  containerId: z.string()
+});
+var codeInterpreterOutputSchema = z.object({
+  outputs: z.array(z.discriminatedUnion("type", [
+    z.object({ type: z.literal("logs"), logs: z.string() }),
+    z.object({ type: z.literal("image"), url: z.string() })
+  ])).nullish()
+});
+var codeInterpreterArgsSchema = z.object({
+  container: z.union([
+    z.string(),
+    z.object({
+      fileIds: z.array(z.string()).optional()
+    })
+  ]).optional()
+});
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "openai.code_interpreter",
+  inputSchema: codeInterpreterInputSchema,
+  outputSchema: codeInterpreterOutputSchema
+});
+var codeInterpreter = (args = {}) => {
+  return codeInterpreterToolFactory(args);
+};
+
+export { codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterArgsSchema, codeInterpreterToolFactory, codeInterpreter };

package/dist/chunks/ripgrep-5fvy871a.js

@@ -0,0 +1,162 @@
+import {
+  exports_repository
+} from "./ripgrep-1kvtxahz.js";
+import {
+  exports_git
+} from "./ripgrep-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  validateBranch: () => validateBranch,
+  node: () => node,
+  isError: () => isError,
+  Service: () => Service,
+  ResetFailedError: () => ResetFailedError,
+  RepositoryCache: () => exports_repository_cache,
+  LockFailedError: () => LockFailedError,
+  InvalidBranchError: () => InvalidBranchError,
+  FetchFailedError: () => FetchFailedError,
+  CloneFailedError: () => CloneFailedError,
+  CheckoutFailedError: () => CheckoutFailedError,
+  CacheOperationError: () => CacheOperationError
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { EffectFlock } from "@opencode-ai/util/effect-flock";
+
+class InvalidBranchError extends Schema.TaggedErrorClass()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError extends Schema.TaggedErrorClass()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError extends Schema.TaggedErrorClass()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError extends Schema.TaggedErrorClass()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError extends Schema.TaggedErrorClass()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError(error) {
+  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+}
+var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => exports_repository.validateBranch(branch),
+    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  return Service.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch(input.branch);
+      const repository = input.reference.label;
+      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      return yield* flock.withLock(Effect.gen(function* () {
+        yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
+        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const status = !reuse ? "cloned" : input.refresh ? "refreshed" : "cached";
+        if (status === "cloned") {
+          yield* git.repo.clone({
+            remote: input.reference.remote,
+            directory: AbsolutePath.make(localPath),
+            branch: input.branch
+          }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+        }
+        if (status === "refreshed") {
+          if (!existing)
+            return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
+          yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          if (input.branch) {
+            yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          }
+          const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
+          if (branch) {
+            yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+          }
+          const target = branch ?? (yield* git.history.branch(existing));
+          yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        return {
+          repository,
+          host: input.reference.host,
+          remote: input.reference.remote,
+          localPath,
+          status,
+          head: checkout ? yield* git.history.head(checkout) : undefined,
+          branch: checkout ? yield* git.history.branch(checkout) : undefined
+        };
+      }), `repository-cache:${localPath}`).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };

package/dist/chunks/ripgrep-5gbvd8db.js

@@ -0,0 +1,115 @@
+import {
+  configuredSettings
+} from "./ripgrep-th2whxwy.js";
+import {
+  iife
+} from "./ripgrep-ehj9csmv.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+var providerID = exports_provider.ID.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin = define({
+  id: "opencode.provider.cloudflare-workers-ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(providerID);
+    const form = iife(() => {
+      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {}))
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "accountId",
+          title: "Enter your Cloudflare Account ID",
+          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          form
+        }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      evt.provider.update(item.provider.id, (provider) => {
+        if (!exports_provider.isAISDK(provider.package))
+          return;
+        if (typeof provider.settings?.baseURL === "string")
+          return;
+        const accountId = resolveAccountId(provider.settings ?? {});
+        if (accountId)
+          provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) };
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      if (evt.package !== "@ai-sdk/openai-compatible")
+        return;
+      const accountId = resolveAccountId(evt.options);
+      if (!hasWorkersEndpoint(evt.model) && !accountId)
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(sdkOptions({
+        ...evt.options,
+        baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined)
+      }, ctx.app));
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+function resolveAccountId(options) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+}
+function workersEndpoint(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`;
+}
+function hasWorkersEndpoint(model) {
+  return exports_provider.isAISDK(model.package) && typeof model.settings?.baseURL === "string";
+}
+function sdkOptions(options, app) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${exports_app.useragent(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers
+    },
+    name: providerID
+  };
+}
+function expandAccountId(baseURL) {
+  if (typeof baseURL !== "string")
+    return baseURL;
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}");
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareWorkersAIPlugin };

package/dist/chunks/ripgrep-5p2sx24b.js

@@ -0,0 +1,56 @@
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  generate: () => generate,
+  VariantPlugin: () => exports_variant,
+  Plugin: () => Plugin
+});
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var Plugin = define({
+  id: "opencode.variant",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((catalog) => {
+      for (const record of catalog.provider.list()) {
+        for (const model of record.models.values()) {
+          catalog.model.update(model.providerID, model.id, (draft) => {
+            const generated = generate(draft, record.provider);
+            if (generated.length === 0)
+              return;
+            const variants = draft.variants ?? [];
+            const explicit = new Map(variants.map((variant) => [variant.id, variant]));
+            const generatedIDs = new Set(generated.map((variant) => variant.id));
+            draft.variants = [
+              ...generated.map((variant) => explicit.get(variant.id) ?? variant),
+              ...variants.filter((variant) => !generatedIDs.has(variant.id))
+            ];
+          });
+        }
+      }
+    });
+  })
+});
+function generate(model, provider) {
+  const packageName = model.package ?? provider?.package;
+  if (!exports_provider.isAISDK(packageName) || exports_provider.packageName(packageName) !== "@ai-sdk/openai-compatible")
+    return [];
+  const ids = `${model.id} ${model.modelID ?? ""}`.toLowerCase();
+  if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
+    return [];
+  return ["high", "max"].map((id) => ({
+    id: exports_model.VariantID.make(id),
+    settings: { reasoningEffort: id }
+  }));
+}
+
+export { Plugin, generate, exports_variant };

package/dist/chunks/ripgrep-5pfeh60c.js

@@ -0,0 +1,154 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./ripgrep-zthe9zqc.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/environment/exec-defaults.ts
+var exports_exec_defaults = {};
+__export(exports_exec_defaults, {
+  execDefaults: () => execDefaults,
+  EnvironmentExecDefaults: () => exports_exec_defaults
+});
+import { Effect, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { collectStream } from "@opencode-ai/util/process";
+var MAX_DATA_BYTES = 64 * 1024 * 1024;
+var MAX_ERROR_BYTES = 64 * 1024;
+var NOT_FOUND = 44;
+var WRONG_KIND = 45;
+var FAILED = 46;
+var TAB = "\t";
+var loadMetadata = (flags = "") => `
+metadata=$(stat ${flags} -c '%F${TAB}%s${TAB}%Y' -- "$1" 2>&1) || {
+  case "$metadata" in
+    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
+    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
+  esac
+}
+`;
+var statScript = `
+${loadMetadata()}
+printf '%s
+' "$metadata"
+`;
+var readScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+printf '%s
+' "$metadata"
+if [ "$2" = range ]; then
+  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
+else
+  cat -- "$1"
+fi
+`;
+var listScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != directory ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+find -H "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
+`;
+var moveScript = `
+${loadMetadata()}
+mv -- "$1" "$2"
+`;
+var execDefaults = (spawner) => {
+  const run = (path, script, args = [], stdin) => Effect.scoped(Effect.gen(function* () {
+    const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
+      env: { LC_ALL: "C" },
+      extendEnv: true,
+      stdin: stdin === undefined ? undefined : Stream.make(stdin)
+    });
+    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    const [stdout, stderr, exitCode] = yield* Effect.all([
+      collectStream(handle.stdout, MAX_DATA_BYTES),
+      collectStream(handle.stderr, MAX_ERROR_BYTES),
+      handle.exitCode
+    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    if (stdout.truncated || stderr.truncated) {
+      return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") });
+    }
+    return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer };
+  }));
+  const classify = (path, result, success) => {
+    if (result.exitCode === 0)
+      return Effect.sync(() => success(result.stdout));
+    if (result.exitCode === NOT_FOUND)
+      return Effect.fail(new NotFound({ path }));
+    if (result.exitCode === WRONG_KIND) {
+      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
+    }
+    return Effect.fail(processFailure(path, result));
+  };
+  const complete = (path, result) => result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result));
+  return {
+    stat: (path) => run(path, statScript).pipe(Effect.flatMap((result) => classifyPlain(path, result, parseInfo))),
+    read: (path, range) => run(path, readScript, range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)]).pipe(Effect.flatMap((result) => classify(path, result, (stdout) => {
+      const newline = stdout.indexOf(10);
+      if (newline < 0)
+        throw new Error("Missing read metadata header");
+      return {
+        info: parseInfo(stdout.slice(0, newline)),
+        bytes: stdout.slice(newline + 1)
+      };
+    }))),
+    write: (path, bytes) => run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(Effect.flatMap((result) => complete(path, result))),
+    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
+    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+    move: (from, to) => run(from, moveScript, [to]).pipe(Effect.flatMap((result) => classifyPlain(from, result, () => {
+      return;
+    }))),
+    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result)))
+  };
+};
+var classifyPlain = (path, result, success) => {
+  if (result.exitCode === 0)
+    return Effect.sync(() => success(result.stdout));
+  if (result.exitCode === NOT_FOUND)
+    return Effect.fail(new NotFound({ path }));
+  return Effect.fail(processFailure(path, result));
+};
+var processFailure = (path, result) => new Failed({
+  path,
+  cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`)
+});
+var parseInfo = (bytes) => {
+  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split(TAB);
+  const size = Number(rawSize);
+  const mtimeMs = Number(rawMtime) * 1000;
+  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs))
+    throw new Error("Invalid stat output");
+  return { type: parseType(rawType), size, mtimeMs };
+};
+var parseType = (value) => {
+  if (value === "regular file" || value === "regular empty file" || value === "f")
+    return "file";
+  if (value === "directory" || value === "d")
+    return "directory";
+  if (value === "symbolic link" || value === "l")
+    return "symlink";
+  return "other";
+};
+var parseList = (bytes) => {
+  const fields = new TextDecoder().decode(bytes).split("\x00");
+  fields.pop();
+  if (fields.length % 2 !== 0)
+    throw new Error("Invalid find output");
+  return Array.from({ length: fields.length / 2 }, (_, index) => ({
+    name: fields[index * 2 + 1],
+    type: parseType(fields[index * 2])
+  }));
+};
+
+export { execDefaults, exports_exec_defaults };

package/dist/chunks/ripgrep-5rs65q6p.js

@@ -0,0 +1,65 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/database/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  makeConnection: () => makeConnection,
+  makeClient: () => makeClient,
+  Sqlite: () => exports_sqlite,
+  Native: () => Native
+});
+import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect";
+import { identity } from "effect/Function";
+import { SqlClient, Statement } from "effect/unstable/sql";
+
+class Native extends Context.Service()("@opencode-ai/core/database/SqliteNative") {
+}
+var makeConnection = (run, runValues, extensions) => identity({
+  execute(query, params, transformRows) {
+    return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params);
+  },
+  executeRaw(query, params) {
+    return run(query, params);
+  },
+  executeValues(query, params) {
+    return runValues(query, params);
+  },
+  executeValuesUnprepared(query, params) {
+    return runValues(query, params);
+  },
+  executeUnprepared(query, params, transformRows) {
+    return this.execute(query, params, transformRows);
+  },
+  executeStream() {
+    return Stream.die("executeStream not implemented");
+  },
+  ...extensions
+});
+var makeClient = (options, connection, typeId, extensions) => Effect.gen(function* () {
+  const semaphore = yield* Semaphore.make(1);
+  const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+  const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+    const fiber = Fiber.getCurrent();
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+    return Effect.as(Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
+  return Object.assign(yield* SqlClient.make({
+    acquirer,
+    compiler: Statement.makeCompilerSqlite(options.transformQueryNames),
+    transactionAcquirer,
+    spanAttributes: [
+      ...options.spanAttributes ? Object.entries(options.spanAttributes) : [],
+      ["db.system.name", "sqlite"]
+    ],
+    transformRows
+  }), {
+    [typeId]: typeId,
+    config: options,
+    ...extensions(acquirer)
+  });
+});
+
+export { Native, makeConnection, makeClient, exports_sqlite };