@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-p6v0vyws.js

@@ -0,0 +1,182 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Service68,
+  node72
+} from "./repository-1gnhqkth.js";
+import {
+  parse4,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./repository-2402vzrj.js";
+import {
+  Service63,
+  node67
+} from "./repository-ksjan0t5.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
+  RepositoryCache: () => exports_repository_cache,
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service56,
+  isError: () => isError2,
+  node: () => node60,
+  validateBranch: () => validateBranch2
+});
+import path from "path";
+import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { EffectFlock } from "@opencode/util/effect-flock";
+var Refresh = Schema.Struct({
+  attemptedAt: Schema.Number
+});
+var refreshInterval = Duration.toMillis(Duration.days(1));
+
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service56 extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError2(error) {
+  return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
+}
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service56, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service68;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  const kv = yield* Service63;
+  return Service56.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch2(input.branch);
+      const repository = input.reference.label;
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
+      const key = `repository-cache:${localPath}`;
+      const cloneTarget = parse4(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(AbsolutePath2.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? parse4(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const now = yield* Clock.currentTimeMillis;
+        const previous = Option.getOrUndefined(Schema.decodeUnknownOption(Refresh)(yield* kv.get(key)));
+        const refresh = input.refresh === "daily" ? !previous || now - previous.attemptedAt >= refreshInterval : input.refresh;
+        const status = !reuse ? "cloned" : refresh ? "refreshed" : "cached";
+        if (status !== "cached") {
+          yield* kv.set(key, { attemptedAt: now });
+          if (status === "cloned") {
+            yield* git.repo.clone({
+              remote: input.reference.remote,
+              directory: AbsolutePath2.make(localPath),
+              branch: input.branch
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
+          }
+          if (status === "refreshed") {
+            if (!existing)
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
+            if (input.branch) {
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ 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 CheckoutFailedError2({ 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 ResetFailedError2({ repository, message: error.message })));
+          }
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath2.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
+        };
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node60 = makeGlobalNode({
+  service: Service56,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, node72, Global.node, node67]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service56, isError2, validateBranch2, node60, exports_repository_cache };

package/dist/chunks/repository-paphc93g.js

@@ -0,0 +1,9 @@
+// src/filesystem/watcher-binding.ts
+import { createRequire } from "node:module";
+function load2() {
+  const require2 = createRequire(import.meta.url);
+  const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC;
+  return require2(process.env.OPENCODE_PARCEL_WATCHER_PATH ?? `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`);
+}
+
+export { load2 };

package/dist/chunks/repository-pctvcs1g.js

@@ -0,0 +1,115 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Key3,
+  removed2,
+  make20,
+  combine2
+} from "./repository-rhjbct0v.js";
+import {
+  InstructionEntryTable2
+} from "./repository-a1bz86dw.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/instruction-entry.ts
+var exports_instruction_entry = {};
+__export(exports_instruction_entry, {
+  Info: () => Info6,
+  InstructionEntry: () => exports_instruction_entry,
+  Key: () => Key2,
+  MaxValueBytes: () => MaxValueBytes2,
+  Service: () => Service35,
+  Snapshot: () => Snapshot2,
+  ValueTooLargeError: () => ValueTooLargeError2,
+  initialize: () => initialize2,
+  node: () => node40,
+  snapshot: () => snapshot2
+});
+import { and, asc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { InstructionEntry } from "@opencode/schema/instruction-entry";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var Key2 = InstructionEntry.Key;
+var Info6 = InstructionEntry.Info;
+var Snapshot2 = InstructionEntry.Snapshot;
+var MaxValueBytes2 = InstructionEntry.MaxValueBytes;
+var ValueTooLargeError2 = InstructionEntry.ValueTooLargeError;
+var InsertBatchSize = 10;
+var snapshot2 = Effect.fn("InstructionEntry.snapshot")(function* (db, sessionID) {
+  return yield* db.select({
+    key: InstructionEntryTable2.key,
+    value: InstructionEntryTable2.value,
+    removed: InstructionEntryTable2.removed
+  }).from(InstructionEntryTable2).where(eq(InstructionEntryTable2.session_id, sessionID)).orderBy(asc(InstructionEntryTable2.key)).all().pipe(Effect.orDie);
+});
+var initialize2 = Effect.fn("InstructionEntry.initialize")(function* (db, sessionID, entries, created) {
+  const batches = Array.from({ length: Math.ceil(entries.length / InsertBatchSize) }, (_, index) => entries.slice(index * InsertBatchSize, (index + 1) * InsertBatchSize));
+  yield* Effect.forEach(batches, (batch) => db.insert(InstructionEntryTable2).values(batch.map((entry) => ({
+    ...entry,
+    session_id: sessionID,
+    time_created: created,
+    time_updated: created
+  }))).run().pipe(Effect.orDie), { discard: true });
+});
+
+class Service35 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) => make20({
+  key: Key3.make(`api/${entry.key}`),
+  codec: Schema.toCodecJson(Schema.Json),
+  read: Effect.succeed(entry.removed ? removed2 : 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(Service35, Effect.gen(function* () {
+  const { db } = yield* Service79;
+  const rows = Effect.fnUntraced(function* (sessionID, includeRemoved) {
+    return yield* db.select({
+      key: InstructionEntryTable2.key,
+      value: InstructionEntryTable2.value,
+      removed: InstructionEntryTable2.removed
+    }).from(InstructionEntryTable2).where(and(eq(InstructionEntryTable2.session_id, sessionID), includeRemoved ? undefined : eq(InstructionEntryTable2.removed, false))).orderBy(asc(InstructionEntryTable2.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 > MaxValueBytes2)
+      yield* new ValueTooLargeError2({
+        actualBytes,
+        maxBytes: MaxValueBytes2,
+        message: `Instruction entry value is ${actualBytes} bytes; the limit is ${MaxValueBytes2} bytes`
+      });
+    const changed = input.value === null ? isNotNull(InstructionEntryTable2.value) : or(isNull(InstructionEntryTable2.value), ne(InstructionEntryTable2.value, input.value));
+    yield* db.insert(InstructionEntryTable2).values({ session_id: input.sessionID, key: input.key, value: input.value, removed: false }).onConflictDoUpdate({
+      target: [InstructionEntryTable2.session_id, InstructionEntryTable2.key],
+      set: { value: input.value, removed: false, time_updated: Date.now() },
+      setWhere: or(eq(InstructionEntryTable2.removed, true), changed)
+    }).run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("InstructionEntry.remove")(function* (input) {
+    yield* db.update(InstructionEntryTable2).set({ value: null, removed: true, time_updated: Date.now() }).where(and(eq(InstructionEntryTable2.session_id, input.sessionID), eq(InstructionEntryTable2.key, input.key), eq(InstructionEntryTable2.removed, false))).run().pipe(Effect.orDie);
+  });
+  const load = Effect.fn("InstructionEntry.load")(function* (sessionID) {
+    return combine2((yield* rows(sessionID, true)).map(source));
+  });
+  return Service35.of({ list, put, remove, load });
+}));
+var node40 = makeLocationNode({ service: Service35, layer, deps: [node84] });
+
+export { Key2, Info6, Snapshot2, MaxValueBytes2, ValueTooLargeError2, snapshot2, initialize2, Service35, node40, exports_instruction_entry };

package/dist/chunks/repository-pecb0brz.js

@@ -0,0 +1,69 @@
+import {
+  PositiveInt2
+} from "./repository-922hggd3.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/mcp.ts
+var exports_mcp5 = {};
+__export(exports_mcp5, {
+  ConfigMCPV1: () => exports_mcp5,
+  Info: () => Info10,
+  Local: () => Local2,
+  OAuth: () => OAuth2,
+  Remote: () => Remote2
+});
+import { Schema } from "effect";
+var Local2 = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server"
+  }),
+  cwd: Schema.optional(Schema.String).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server"
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpLocalConfig" });
+var OAuth2 = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)"
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  callbackPort: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))).annotate({
+    description: "Port for the local OAuth callback server (default: 19876). Shorthand for redirectUri when only the port needs changing. Ignored if redirectUri is set."
+  }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
+  })
+}).annotate({ identifier: "McpOAuthConfig" });
+var Remote2 = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request"
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth2, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpRemoteConfig" });
+var Info10 = Schema.Union([Local2, Remote2]).annotate({ discriminator: "type" });
+
+export { Local2, OAuth2, Remote2, Info10, exports_mcp5 };

package/dist/chunks/repository-peejr10p.js

@@ -0,0 +1,28 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/kilo.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var KiloPlugin2 = define({
+  id: "opencode.provider.kilo",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://api.kilo.ai/api/gateway")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { KiloPlugin2 };

package/dist/chunks/repository-penaav09.js

@@ -0,0 +1,190 @@
+import {
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service25,
+  node29
+} from "./repository-ztky2hbm.js";
+import {
+  isHome2,
+  names3
+} from "./repository-tcezcvh9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  FileSystemSearch: () => exports_search,
+  Options: () => Options4,
+  Service: () => Service24,
+  configured: () => configured4,
+  fffLayer: () => fffLayer2,
+  layer: () => layer10,
+  node: () => node28,
+  ripgrepLayer: () => ripgrepLayer2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import path from "path";
+import { Clock, Context, Deferred, Duration, Effect, Layer, Schema, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+import { FileSystem } from "@opencode/schema/filesystem";
+var Options4 = Schema.Struct({
+  fff: Schema.optional(Schema.Boolean)
+});
+
+class Service24 extends Context.Service()("@opencode/FileSystem/Search") {
+}
+var REFRESH_INTERVAL = Duration.toMillis("10 seconds");
+function emptyIndex() {
+  return { files: new Map, directories: new Map };
+}
+function search(index, input) {
+  const items = input.type === "file" ? Array.from(index.files.values()) : input.type === "directory" ? Array.from(index.directories.values()) : [...index.files.values(), ...index.directories.values()];
+  const result = fuzzysort.go(input.query, items, { limit: input.limit ?? 50 });
+  fuzzysort.cleanup();
+  return result.map((item) => {
+    const relative = item.target;
+    const type = relative.endsWith(path.sep) ? "directory" : "file";
+    return FileSystem.Entry.make({
+      path: RelativePath2.make(relative),
+      type
+    });
+  });
+}
+var ripgrepLayer2 = Layer.effect(Service24, Effect.gen(function* () {
+  const location = yield* Service66;
+  const ripgrep = yield* Service25;
+  const scope = yield* Scope.Scope;
+  const clock = yield* Clock.Clock;
+  const home = isHome2(location.directory);
+  let index = emptyIndex();
+  let initialized = false;
+  let settledAt = Number.NEGATIVE_INFINITY;
+  let refreshing;
+  const scan = Effect.gen(function* () {
+    const next = emptyIndex();
+    const previous = index;
+    if (!initialized)
+      index = next;
+    yield* ripgrep.find({
+      cwd: location.directory,
+      pattern: "*",
+      limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 1e5,
+      exclude: home ? [...names3()].map((name) => `${name}/**`) : undefined,
+      onEntry: (entry) => Effect.sync(() => {
+        next.files.set(entry.path, previous.files.get(entry.path) ?? fuzzysort.prepare(entry.path));
+        const parts = entry.path.split("/");
+        parts.slice(0, -1).forEach((_, offset) => {
+          const directory = parts.slice(0, offset + 1).join("/") + path.sep;
+          if (!next.directories.has(directory))
+            next.directories.set(directory, previous.directories.get(directory) ?? fuzzysort.prepare(directory));
+        });
+      })
+    });
+    index = next;
+    initialized = true;
+  }).pipe(Effect.orDie);
+  const refresh = Effect.suspend(() => {
+    if (refreshing)
+      return initialized ? Effect.void : Deferred.await(refreshing);
+    if (initialized && clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL)
+      return Effect.void;
+    const attempt = Deferred.makeUnsafe();
+    refreshing = attempt;
+    return scan.pipe(Effect.onExit((exit) => Effect.sync(() => {
+      settledAt = clock.currentTimeMillisUnsafe();
+      if (refreshing === attempt)
+        refreshing = undefined;
+      Deferred.doneUnsafe(attempt, exit);
+    })), Effect.forkIn(scope), Effect.flatMap(() => initialized ? Effect.void : Deferred.await(attempt)));
+  });
+  return Service24.of({
+    find: (input) => Effect.gen(function* () {
+      yield* refresh;
+      return search(index, input);
+    })
+  });
+}));
+var fffLayer2 = Layer.effect(Service24, Effect.gen(function* () {
+  const location = yield* Service66;
+  const result = yield* Effect.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect.logWarning("failed to initialize fff", { error: result.error });
+    return Service24.of({
+      find: () => Effect.succeed([])
+    });
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()));
+  return Service24.of({
+    find: (input) => Effect.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found = result.value.fileSearch(input.query.trim(), options);
+          if (!found.ok)
+            throw found.error;
+          return found.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found = result.value.directorySearch(input.query.trim(), options);
+          if (!found.ok)
+            throw found.error;
+          return found.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found.value.scores[index]?.total ?? 0
+          }));
+        }
+        const found = result.value.mixedSearch(input.query.trim(), options);
+        if (!found.ok)
+          throw found.error;
+        return found.value.items.map((item, index) => ({
+          path: item.item.relativePath,
+          type: item.type,
+          score: found.value.scores[index]?.total ?? 0
+        }));
+      })();
+      return items.sort((a, b) => b.score - a.score || a.path.length - b.path.length).map((item) => {
+        const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "");
+        return FileSystem.Entry.make({
+          path: RelativePath2.make(relative + (item.type === "directory" ? path.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer10 = (options) => Layer.unwrap(Effect.gen(function* () {
+  const location = yield* Service66;
+  if (location.workspaceID)
+    return ripgrepLayer2;
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer2;
+  return location.vcs && !isHome2(location.directory) ? fffLayer2 : ripgrepLayer2;
+}));
+function configured4(options) {
+  return makeLocationNode({ service: Service24, layer: layer10(options), deps: [node70, node29] });
+}
+var node28 = configured4();
+
+export { Options4, Service24, ripgrepLayer2, fffLayer2, layer10, configured4, node28, exports_search };

package/dist/chunks/repository-petjzngd.js

@@ -0,0 +1,37 @@
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service57
+} from "./repository-3ke3s58r.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/shell.ts
+var exports_shell = {};
+__export(exports_shell, {
+  ConfigShellPlugin: () => exports_shell,
+  Plugin: () => Plugin8
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin8 = define({
+  id: "opencode.config.shell",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const shell = yield* Service57;
+    const loaded = yield* observe2(config, ctx.event, shell.reload());
+    yield* shell.transform((editor) => {
+      const configured = latest2(loaded.entries, "shell");
+      if (configured)
+        editor.configure(configured);
+    });
+  })
+});
+
+export { Plugin8, exports_shell };

package/dist/chunks/repository-pjrv1sn1.js

@@ -0,0 +1,24 @@
+import {
+  packageName2
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var CerebrasPlugin2 = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        const name = packageName2(item.provider.package);
+        if (name !== "@ai-sdk/cerebras" && name !== "@opencode/ai/providers/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { CerebrasPlugin2 };