@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-j2hktz7g.js

@@ -0,0 +1,205 @@
+import {
+  exports_directories
+} from "./permission-at95jcnb.js";
+import {
+  exports_schema
+} from "./permission-gm8kdh5e.js";
+import {
+  ProjectTable,
+  upsertProject
+} from "./permission-88jbfw8z.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  exports_git
+} from "./permission-z66vzcey.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/project.ts
+var exports_project = {};
+__export(exports_project, {
+  root: () => root,
+  node: () => node,
+  Vcs: () => Vcs,
+  Service: () => Service,
+  Project: () => exports_project,
+  Info: () => Info,
+  ID: () => ID,
+  Directory: () => Directory,
+  DirectoriesInput: () => DirectoriesInput,
+  Directories: () => Directories,
+  Current: () => Current
+});
+import { Context, Effect, Layer } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { asc, desc } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { AppProcess } from "@opencode-ai/util/process";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Hash } from "@opencode-ai/util/hash";
+var ID = exports_schema.ID;
+var Vcs = exports_schema.Vcs;
+var Current = exports_schema.Current;
+var Directory = exports_schema.Directory;
+var Info = exports_schema.Info;
+var DirectoriesInput = exports_schema.DirectoriesInput;
+var Directories = exports_schema.Directories;
+var root = Effect.fn("Project.root")(function* (fs, input) {
+  return yield* fs.up({ targets: [".git", ".hg"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath.make(path.dirname(matches[0])) : undefined), Effect.catch(() => Effect.succeed(undefined)));
+});
+
+class Service extends Context.Service()("@opencode/Project") {
+}
+function fromRow(row) {
+  const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
+    url: row.icon_url ?? undefined,
+    override: row.icon_url_override ?? undefined,
+    color: row.icon_color ?? undefined
+  } : undefined;
+  return {
+    id: row.id,
+    canonical: row.worktree,
+    vcs: row.vcs ?? undefined,
+    name: row.name ?? undefined,
+    icon,
+    commands: row.commands ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      initialized: row.time_initialized ?? undefined
+    },
+    sandboxes: row.sandboxes
+  };
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const proc = yield* AppProcess.Service;
+  const db = (yield* exports_database.Service).db;
+  const projectDirectories = yield* exports_directories.Service;
+  const persist = Effect.fnUntraced(function* (project) {
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* upsertProject(tx, project);
+      if (!project.vcs)
+        return;
+      yield* projectDirectories.create({ projectID: project.id, directory: project.canonical }, tx);
+      if (project.directory === project.canonical)
+        return;
+      yield* projectDirectories.create({
+        projectID: project.id,
+        directory: project.directory,
+        strategy: project.vcs.type === "git" ? "git_worktree" : undefined
+      }, tx);
+    })).pipe(Effect.orDie);
+    return project;
+  });
+  const list = Effect.fn("Project.list")(function* () {
+    const rows = yield* db.select().from(ProjectTable).orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id)).all().pipe(Effect.orDie);
+    return rows.map(fromRow);
+  });
+  const directories = Effect.fn("Project.directories")(function* (input) {
+    return yield* projectDirectories.list(input.projectID);
+  });
+  const cached = Effect.fnUntraced(function* (dir) {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID.make(value) : undefined), Effect.catch(() => Effect.succeed(undefined)));
+  });
+  const remote = Effect.fnUntraced(function* (repo) {
+    const origin = yield* git.remote.get(repo);
+    if (!origin)
+      return;
+    const normalized = url(origin);
+    if (!normalized)
+      return;
+    return ID.make(Hash.fast(`git-remote:${normalized}`));
+  });
+  function url(input) {
+    const value = input.trim();
+    if (!value)
+      return;
+    try {
+      const parsed = new URL(value);
+      if (parsed.protocol === "file:")
+        return;
+      return parts(parsed.hostname, parsed.pathname);
+    } catch {
+      const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/);
+      if (scp)
+        return parts(scp[2], scp[3]);
+      return;
+    }
+  }
+  function parts(host, name) {
+    const pathname = name.replace(/^\/+/, "").replace(/\.git\/?$/, "").replace(/\/+$/, "");
+    if (!host || !pathname)
+      return;
+    return `${host.toLowerCase()}/${pathname}`;
+  }
+  const root2 = Effect.fnUntraced(function* (repo) {
+    const root3 = (yield* git.history.rootCommits(repo))[0];
+    return root3 ? ID.make(root3) : undefined;
+  });
+  const hgRoot = Effect.fnUntraced(function* (worktree) {
+    const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
+`], {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    })).pipe(Effect.catch(() => Effect.succeed(undefined)));
+    if (!result || result.exitCode !== 0)
+      return;
+    const node = result.stdout.toString("utf8").split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted()[0];
+    return node ? ID.make(node) : undefined;
+  });
+  const hgDiscover = Effect.fnUntraced(function* (input) {
+    const dotHg = yield* fs.up({ targets: [".hg"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.catch(() => Effect.succeed(undefined)));
+    if (!dotHg)
+      return;
+    const worktree = AbsolutePath.make(path.dirname(dotHg));
+    const store = AbsolutePath.make(dotHg);
+    const previous = yield* cached(store);
+    const id = previous ?? (yield* hgRoot(worktree));
+    return {
+      previous,
+      id: id ?? ID.global,
+      directory: worktree,
+      vcs: { type: "hg", store }
+    };
+  });
+  const resolve = Effect.fn("Project.resolve")(function* (input) {
+    const repo = yield* git.repo.discover(input);
+    if (repo) {
+      const previous = yield* cached(repo.commonDirectory);
+      const id = (yield* remote(repo)) ?? previous ?? (yield* root2(repo));
+      const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.catch(() => Effect.succeed(repo.worktree)));
+      return yield* persist({
+        previous,
+        id: id ?? ID.global,
+        directory: repo.worktree,
+        canonical,
+        vcs: { type: "git", store: repo.commonDirectory }
+      });
+    }
+    const hg = yield* hgDiscover(input);
+    if (hg)
+      return yield* persist({ ...hg, canonical: hg.directory });
+    const directory = AbsolutePath.make(path.parse(input).root);
+    return yield* persist({ id: ID.global, directory, canonical: directory, vcs: undefined });
+  });
+  return Service.of({ list, directories, resolve });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [exports_database.node, FSUtil.node, exports_git.node, AppProcess.node, exports_directories.node]
+});
+
+export { ID, Vcs, Current, Directory, Info, DirectoriesInput, Directories, root, Service, node, exports_project };

package/dist/chunks/permission-j32ayx7z.js

@@ -0,0 +1,86 @@
+import {
+  exports_hg
+} from "./permission-ph1me6ah.js";
+import {
+  exports_git
+} from "./permission-rt6yg6j2.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  node: () => node,
+  Vcs: () => exports_vcs,
+  Service: () => Service,
+  Mode: () => Mode,
+  Info: () => Info,
+  FileStatus: () => FileStatus
+});
+import path from "path";
+import { Context, Effect, Layer, Stream } from "effect";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs";
+import { VcsEvent } from "@opencode-ai/schema/vcs-event";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { AppProcess } from "@opencode-ai/util/process";
+class Service extends Context.Service()("@opencode/Vcs") {
+}
+var adapter = (proc, fs, location) => {
+  const scope = { directory: location.directory, worktree: location.project.directory };
+  if (location.vcs?.type === "git")
+    return exports_git.make(proc, scope);
+  if (location.vcs?.type === "hg")
+    return exports_hg.make(proc, fs, scope);
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const proc = yield* AppProcess.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const bus = yield* exports_bus.Service;
+  const impl = adapter(proc, fs, location);
+  const vcs = location.vcs;
+  const state = { info: impl ? yield* impl.info() : { branch: {} } };
+  if (vcs && impl) {
+    const store = yield* fs.realPath(vcs.store).pipe(Effect.catch(() => Effect.succeed(vcs.store)));
+    const isBranchMetadata = vcs.type === "git" ? (file) => path.basename(file) === "HEAD" && FSUtil.contains(store, file) : (file) => path.resolve(file) === path.join(store, "branch");
+    yield* bus.subscribe(FileSystem.Event.Changed).pipe(Stream.filter((event) => isBranchMetadata(event.data.file)), Stream.runForEach((event) => Effect.gen(function* () {
+      const next = yield* impl.info();
+      const changed = state.info.branch.current !== next.branch.current;
+      state.info = next;
+      if (!changed)
+        return;
+      yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current });
+    }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } }))), Effect.forkScoped({ startImmediately: true }));
+  }
+  return Service.of({
+    info: Effect.fn("Vcs.info")(function* () {
+      return state.info;
+    }),
+    status: Effect.fn("Vcs.status")(function* () {
+      if (!impl)
+        return [];
+      return yield* impl.status();
+    }),
+    diff: Effect.fn("Vcs.diff")(function* (mode, options) {
+      if (!impl)
+        return [];
+      return yield* impl.diff(mode, options);
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [AppProcess.node, FSUtil.node, exports_location.node, exports_bus.node]
+});
+
+export { FileStatus, Info, Mode, Service, node, exports_vcs };

package/dist/chunks/permission-jcd3zvtj.js

@@ -0,0 +1,75 @@
+import {
+  exports_reference
+} from "./permission-anrqexna.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/reference.ts
+var exports_reference2 = {};
+__export(exports_reference2, {
+  Plugin: () => Plugin,
+  ConfigReferencePlugin: () => exports_reference2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import path from "path";
+import { Effect, Stream } from "effect";
+import { Global } from "@opencode-ai/util/global";
+var Plugin = define({
+  id: "opencode.config.reference",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const location = yield* exports_location.Service;
+    const global = yield* Global.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.reference.transform((draft) => {
+      const entries = new Map;
+      for (const doc of loaded.entries.filter((entry) => entry.type === "document")) {
+        const directory = doc.path ? path.dirname(doc.path) : location.directory;
+        for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
+          if (!validAlias(name))
+            continue;
+          const description = typeof entry === "string" ? undefined : entry.description;
+          const hidden = typeof entry === "string" ? undefined : entry.hidden;
+          entries.set(name, local(entry) ? exports_reference.LocalSource.make({
+            type: "local",
+            path: AbsolutePath.make(localPath(directory, global.home, typeof entry === "string" ? entry : entry.path)),
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }) : exports_reference.GitSource.make({
+            type: "git",
+            repository: typeof entry === "string" ? entry : entry.repository,
+            ...entry.branch === undefined ? {} : { branch: entry.branch },
+            ...description === undefined ? {} : { description },
+            ...hidden === undefined ? {} : { hidden }
+          }));
+        }
+      }
+      for (const [name, source] of entries)
+        draft.add(name, source);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.reference.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function validAlias(name) {
+  return name.length > 0 && !/[\/\s`,]/.test(name);
+}
+function local(entry) {
+  return typeof entry === "string" ? entry.startsWith(".") || entry.startsWith("/") || entry.startsWith("~") : ("path" in entry);
+}
+function localPath(directory, home, value) {
+  if (value.startsWith("~/"))
+    return path.join(home, value.slice(2));
+  return path.isAbsolute(value) ? value : path.resolve(directory, value);
+}
+
+export { Plugin, exports_reference2 as exports_reference };

package/dist/chunks/permission-jm82nbh8.js

@@ -0,0 +1,259 @@
+import {
+  exports_protected
+} from "./permission-kg1345f7.js";
+import {
+  exports_ripgrep
+} from "./permission-wvha5myg.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  PositiveInt,
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  ripgrepLayer: () => ripgrepLayer,
+  node: () => node2,
+  layer: () => layer,
+  fffLayer: () => fffLayer,
+  configured: () => configured,
+  Service: () => Service2,
+  Options: () => Options,
+  FileSystemSearch: () => exports_search
+});
+import { makeLocationNode as makeLocationNode2 } from "@opencode-ai/util/effect/app-node";
+import path2 from "path";
+import { Context as Context2, Effect as Effect2, Layer as Layer2, Schema as Schema2, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+
+// src/filesystem.ts
+var exports_filesystem = {};
+__export(exports_filesystem, {
+  node: () => node,
+  Submatch: () => Submatch,
+  Service: () => Service,
+  ReadInput: () => ReadInput,
+  Match: () => Match,
+  ListInput: () => ListInput,
+  GrepInput: () => GrepInput,
+  GlobInput: () => GlobInput,
+  FindInput: () => FindInput,
+  FileSystem: () => exports_filesystem,
+  Event: () => Event,
+  Entry: () => Entry2,
+  DEFAULT_SEARCH_TIMEOUT_MS: () => DEFAULT_SEARCH_TIMEOUT_MS,
+  DEFAULT_SEARCH_LIMIT: () => DEFAULT_SEARCH_LIMIT,
+  Content: () => Content
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Entry, FileSystem, FindInput } from "@opencode-ai/schema/filesystem";
+import { Entry as Entry2, Match, Submatch } from "@opencode-ai/schema/filesystem";
+var ReadInput = Schema.Struct({
+  path: RelativePath
+});
+var Content = Schema.Struct({
+  uri: Schema.String,
+  name: Schema.String.pipe(Schema.optional),
+  content: Schema.String,
+  encoding: Schema.Literals(["utf8", "base64"]),
+  mime: Schema.String
+}).annotate({ identifier: "FileSystem.Content" });
+var ListInput = Schema.Struct({
+  path: RelativePath.pipe(Schema.optional)
+});
+var DEFAULT_SEARCH_LIMIT = 100;
+var DEFAULT_SEARCH_TIMEOUT_MS = 30000;
+
+class GlobInput extends Schema.Class("FileSystem.GlobInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+
+class GrepInput extends Schema.Class("FileSystem.GrepInput")({
+  pattern: Schema.String,
+  path: Schema.optionalKey(RelativePath),
+  include: Schema.optionalKey(Schema.String),
+  limit: Schema.optionalKey(PositiveInt)
+}) {
+}
+var Event = FileSystem.Event;
+
+class Service extends Context.Service()("@opencode/FileSystem") {
+}
+var baseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const search = yield* exports_search.Service;
+  const root = yield* fs.realPath(location.directory).pipe(Effect.orDie);
+  const resolve = Effect.fnUntraced(function* (input) {
+    const absolute = path.resolve(location.directory, input ?? ".");
+    if (!FSUtil.contains(location.directory, absolute))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    const real = yield* fs.realPath(absolute).pipe(Effect.orDie);
+    if (!FSUtil.contains(root, real))
+      return yield* Effect.die(new Error("Path escapes the location"));
+    return { absolute, real, directory: location.directory, root };
+  });
+  return Service.of({
+    find: search.find,
+    read: Effect.fn("FileSystem.read")(function* (input) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "File")
+        return yield* Effect.die(new Error("Path is not a file"));
+      return {
+        content: yield* fs.readFile(target.real).pipe(Effect.orDie),
+        mime: FSUtil.mimeType(target.real)
+      };
+    }),
+    list: Effect.fn("FileSystem.list")(function* (input = {}) {
+      const target = yield* resolve(input.path);
+      const info = yield* fs.stat(target.real).pipe(Effect.orDie);
+      if (info.type !== "Directory")
+        return yield* Effect.die(new Error("Path is not a directory"));
+      return yield* fs.readDirectoryEntries(target.real).pipe(Effect.orDie, Effect.map((items) => items.flatMap((item) => {
+        if (item.type !== "file" && item.type !== "directory")
+          return [];
+        const absolute = path.join(target.absolute, item.name);
+        const relative = path.relative(target.directory, absolute);
+        return [
+          Entry.make({
+            path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+            type: item.type
+          })
+        ];
+      }).sort((a, b) => a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1)));
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer: baseLayer,
+  deps: [FSUtil.node, exports_location.node, exports_search.node]
+});
+
+// src/filesystem/search.ts
+var Options = Schema2.Struct({
+  fff: Schema2.optional(Schema2.Boolean)
+});
+
+class Service2 extends Context2.Service()("@opencode/FileSystem/Search") {
+}
+var ripgrepLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const ripgrep = yield* exports_ripgrep.Service;
+  const scope = yield* Scope.Scope;
+  const files = [];
+  const directories = new Set;
+  const home = exports_protected.isHome(location.directory);
+  yield* ripgrep.find({
+    cwd: location.directory,
+    pattern: "*",
+    limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 1e5,
+    exclude: home ? [...exports_protected.names()].map((name) => `${name}/**`) : undefined,
+    onEntry: (entry) => Effect2.sync(() => {
+      files.push(entry.path);
+      const parts = entry.path.split("/");
+      parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path2.sep));
+    })
+  }).pipe(Effect2.orDie, Effect2.asVoid, Effect2.forkIn(scope));
+  return Service2.of({
+    find: (input) => Effect2.gen(function* () {
+      const items = input.type === "file" ? files : input.type === "directory" ? Array.from(directories) : [...files, ...directories];
+      return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
+        const relative = item.target;
+        const type = relative.endsWith(path2.sep) ? "directory" : "file";
+        return exports_filesystem.Entry.make({
+          path: RelativePath.make(relative),
+          type
+        });
+      });
+    })
+  });
+}));
+var fffLayer = Layer2.effect(Service2, Effect2.gen(function* () {
+  const location = yield* exports_location.Service;
+  const result = yield* Effect2.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect2.catch((error) => Effect2.logWarning("failed to initialize fff", { error }).pipe(Effect2.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect2.logWarning("failed to initialize fff", { error: result.error });
+    return Service2.of({
+      find: () => Effect2.succeed([])
+    });
+  }
+  yield* Effect2.addFinalizer(() => Effect2.sync(() => result.value.destroy()).pipe(Effect2.ignore));
+  return Service2.of({
+    find: (input) => Effect2.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found2 = result.value.fileSearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found2 = result.value.directorySearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found2.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 exports_filesystem.Entry.make({
+          path: RelativePath.make(relative + (item.type === "directory" ? path2.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer = (options) => Layer2.unwrap(Effect2.gen(function* () {
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer;
+  const location = yield* exports_location.Service;
+  return location.vcs && !exports_protected.isHome(location.directory) ? fffLayer : ripgrepLayer;
+}));
+function configured(options) {
+  return makeLocationNode2({ service: Service2, layer: layer(options), deps: [exports_location.node, exports_ripgrep.node] });
+}
+var node2 = configured();
+
+export { Options, Service2 as Service, ripgrepLayer, fffLayer, layer, configured, node2 as node, exports_search, FindInput, ReadInput, Content, ListInput, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_TIMEOUT_MS, GlobInput, GrepInput, Event, Service as Service1, node as node1, exports_filesystem, Entry2 as Entry, Match, Submatch };

package/dist/chunks/permission-jssy2dr3.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./permission-0zz82cjq.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/togetherai.ts
+var TogetherAIPlugin = createProviderPlugin({
+  id: "opencode.provider.togetherai",
+  package: "@ai-sdk/togetherai",
+  load: async (options) => {
+    const { createTogetherAI } = await import("@ai-sdk/togetherai");
+    return createTogetherAI(options);
+  }
+});
+
+export { TogetherAIPlugin };