@opencode-ai/core 0.0.0-beta-18743 → 0.0.0-beta-18955

package/dist/chunks/event-logger-r6n0mc8a.js

@@ -0,0 +1,165 @@
+import {
+  exports_host
+} from "./event-logger-pm6tc1g5.js";
+import {
+  Service,
+  awaitActivation
+} from "./event-logger-esv5q40e.js";
+import {
+  exports_kv
+} from "./event-logger-3r56fk07.js";
+import {
+  exports_state
+} from "./event-logger-dyrfpcd0.js";
+import {
+  exports_bus
+} from "./event-logger-vw7aptj1.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  Event: () => Event,
+  ID: () => ID,
+  Info: () => Info,
+  Plugin: () => exports_plugin,
+  Service: () => Service,
+  Source: () => Source,
+  State: () => State,
+  awaitActivation: () => awaitActivation,
+  node: () => node
+});
+import { Event, ID, Info, Source, State } from "@opencode-ai/schema/plugin";
+import { Plugin } from "@opencode-ai/schema/plugin";
+import { Node } from "@opencode-ai/util/effect/app-node";
+import { Cause, Context, Effect, Exit, Latch, Layer, Logger, References, Scope, Semaphore } from "effect";
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const kv = yield* exports_kv.Service;
+  const scope = yield* Scope.make();
+  const active = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  const ready = yield* Latch.make(true);
+  const pending = new Set;
+  const hold = () => Effect.sync(() => {
+    const token = {};
+    pending.add(token);
+    ready.closeUnsafe();
+    return Effect.sync(() => {
+      if (pending.delete(token) && pending.size === 0)
+        ready.openUnsafe();
+    });
+  });
+  let inventory = [];
+  const list = Effect.fn("Plugin.list")(function* () {
+    return inventory;
+  });
+  const host = yield* exports_host.make({ list });
+  const load = Effect.fnUntraced(function* (plugin) {
+    const child = yield* Scope.fork(scope);
+    const inherit = yield* exports_state.inherit();
+    const loaded = yield* Effect.suspend(() => plugin.effect({ ...host, storage: exports_host.storage(kv, plugin.id) })).pipe(inherit, Effect.updateContext((context) => Context.make(Scope.Scope, child).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void), Effect.exit);
+    if (Exit.isSuccess(loaded))
+      return { scope: child };
+    yield* Effect.logWarning("failed to load plugin", {
+      "plugin.id": plugin.id,
+      cause: loaded.cause
+    });
+    return { error: Cause.pretty(loaded.cause) };
+  });
+  const activate = Effect.fn("Plugin.activate")(function* (plugins, failures = []) {
+    const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }));
+    const ids = new Set;
+    for (const definition of definitions) {
+      if (ids.has(definition.id))
+        yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`));
+      ids.add(definition.id);
+    }
+    yield* Effect.acquireUseRelease(hold(), () => lock.withPermit(Effect.gen(function* () {
+      const current = Array.from(active.values());
+      const changed = definitions.findIndex((definition, index) => {
+        const entry = current[index];
+        return entry?.plugin.id !== definition.id || entry.plugin.revision !== definition.revision;
+      });
+      const prefix = changed === -1 ? definitions.length : changed;
+      for (const definition of definitions.slice(0, prefix)) {
+        const entry = active.get(definition.id);
+        if (entry)
+          active.set(definition.id, { ...entry, plugin: definition });
+      }
+      if (prefix === definitions.length && active.size === definitions.length) {
+        const nextInventory = [...Array.from(active.values()).map(slotInfo), ...failures];
+        if (JSON.stringify(inventory) === JSON.stringify(nextInventory))
+          return;
+        inventory = nextInventory;
+        yield* bus.publish(Plugin.Event.Updated, {});
+        return;
+      }
+      yield* exports_state.batch(Effect.gen(function* () {
+        const previous = new Map(Array.from(active.entries()).slice(prefix));
+        yield* Effect.forEach(Array.from(previous.entries()).toReversed(), ([id, slot]) => Effect.gen(function* () {
+          active.delete(id);
+          if (slot.loaded)
+            yield* Scope.close(slot.loaded.scope, Exit.void);
+        }), { discard: true });
+        for (const definition of definitions.slice(prefix)) {
+          const loaded = yield* load(definition);
+          if (loaded.scope !== undefined) {
+            active.set(definition.id, {
+              plugin: definition,
+              loaded: { plugin: definition, scope: loaded.scope }
+            });
+            continue;
+          }
+          active.set(definition.id, { plugin: definition, error: loaded.error });
+          const fallback = previous.get(definition.id)?.loaded;
+          if (!fallback)
+            continue;
+          const restored = yield* load(fallback.plugin);
+          if (restored.scope !== undefined) {
+            active.set(definition.id, {
+              plugin: definition,
+              loaded: { plugin: fallback.plugin, scope: restored.scope },
+              error: loaded.error
+            });
+            continue;
+          }
+          yield* Effect.logError("failed to restore plugin; deactivating", {
+            "plugin.id": definition.id
+          });
+        }
+        inventory = [...Array.from(active.values()).map(slotInfo), ...failures];
+      }));
+      yield* bus.publish(Plugin.Event.Updated, {});
+    })), (release) => release);
+  });
+  const close = (exit) => lock.withPermit(Effect.gen(function* () {
+    active.clear();
+    yield* exports_state.shutdown(Scope.close(scope, exit));
+  }));
+  yield* Effect.addFinalizer(close);
+  return Service.of({
+    activate,
+    close,
+    awaitActivation: ready.await,
+    hold,
+    list
+  });
+}));
+function slotInfo(slot) {
+  return {
+    id: Plugin.ID.make(slot.plugin.id),
+    source: slot.plugin.source ?? { type: "builtin" },
+    state: slot.error === undefined ? { status: "active" } : { status: "failed", error: slot.error },
+    features: { server: true, ...slot.plugin.features }
+  };
+}
+var node = Node.makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_host.requirements]
+});
+
+export { node, exports_plugin, Event, ID, Info, Source, State };

package/dist/chunks/event-logger-r7a2r1m6.js

@@ -0,0 +1,74 @@
+import {
+  exports_promise
+} from "./event-logger-hy5n5jcn.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/plugin/module.ts
+var exports_module = {};
+__export(exports_module, {
+  LoadError: () => LoadError,
+  PluginModule: () => exports_module,
+  load: () => load
+});
+import { Host } from "@opencode-ai/plugin/host";
+import { Npm } from "@opencode-ai/util/npm";
+import { Effect, Schema } from "effect";
+import path from "path";
+import { stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+var Module = Schema.Struct({
+  default: Schema.Union([
+    Schema.Struct({
+      id: Schema.String,
+      effect: Schema.declare((input) => typeof input === "function")
+    }),
+    Schema.Struct({
+      id: Schema.String,
+      setup: Schema.declare((input) => typeof input === "function")
+    })
+  ])
+});
+
+class LoadError extends Schema.TaggedError()("PluginModule.LoadError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+var load = Effect.fn("PluginModule.load")(function* (operation, options) {
+  const local = path.isAbsolute(operation.target);
+  const npm = yield* Npm.Service;
+  const installed = local ? undefined : options?.install === false ? yield* npm.resolve(operation.target) : yield* npm.add(operation.target);
+  const entrypoints = local && (yield* Effect.promise(() => stat(operation.target))).isFile() ? { server: pathToFileURL(operation.target).href } : yield* Effect.sync(() => Host.resolve(installed ?? { directory: operation.target }));
+  const entrypoint = entrypoints.server;
+  if (!local && options?.install === false && !entrypoint)
+    return { pending: true };
+  if (!entrypoint)
+    return yield* new LoadError({ message: `Plugin entrypoint not found: ${operation.target}` });
+  const target = typeof Bun !== "undefined" ? fileURLToPath(entrypoint).replaceAll("\\", "/") : entrypoint;
+  const source = operation.mtime === undefined ? entrypoint : `${target}?mtime=${operation.mtime}`;
+  yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source });
+  const mod = yield* Effect.promise(() => Host.load(source));
+  const value = (yield* Schema.decodeUnknownEffect(Module)(mod).pipe(Effect.mapError((cause) => new LoadError({
+    message: "Plugin must export a default definition with an id and an effect or setup function.",
+    cause
+  })))).default;
+  const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  return {
+    id: plugin.id,
+    features: {
+      ...entrypoints.tui ? { tui: true } : {},
+      ...entrypoints.rpc ? { rpc: true } : {}
+    },
+    revision: JSON.stringify([operation, installed?.revision]),
+    source: path.isAbsolute(operation.target) ? { type: "local", path: fileURLToPath(entrypoint) } : {
+      type: "package",
+      target: operation.target,
+      ...installed?.version ? { version: installed.version } : {}
+    },
+    effect: (host) => plugin.effect({ ...host, options: operation.options })
+  };
+});
+
+export { LoadError, load, exports_module };

package/dist/chunks/{websearch-02dbfq60.js → event-logger-r7z6wjth.js}

@@ -1,14 +1,14 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/integration/connection.ts
 var exports_connection = {};
 __export(exports_connection, {
-  IntegrationConnection: () => exports_connection,
-  Info: () => Info,
+  CredentialInfo: () => CredentialInfo,
   EnvInfo: () => EnvInfo,
-  CredentialInfo: () => CredentialInfo
+  Info: () => Info,
+  IntegrationConnection: () => exports_connection
 });
 import { Connection } from "@opencode-ai/schema/connection";
 var CredentialInfo = Connection.CredentialInfo;

package/dist/chunks/{websearch-r9d3d23r.js → event-logger-r9d3d23r.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./websearch-k3e42drn.js";
+} from "./event-logger-k3e42drn.js";
 
 // src/formatter/builtins.ts
 import { Effect } from "effect";

package/dist/chunks/{websearch-k9fxkxys.js → event-logger-r9eqmc8s.js}

@@ -1,25 +1,25 @@
-import {
-  exports_form
-} from "./websearch-emhmd4ee.js";
 import {
   exports_permission
-} from "./websearch-682366gn.js";
+} from "./event-logger-mvhmw1qg.js";
 import {
   exports_websearch
-} from "./websearch-mxccen0e.js";
+} from "./event-logger-gse5vfpv.js";
+import {
+  exports_form
+} from "./event-logger-rg8m7c20.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/tool/plugin/websearch.ts
 var exports_websearch2 = {};
 __export(exports_websearch2, {
-  name: () => name,
-  description: () => description,
-  WebSearchTool: () => exports_websearch2,
-  Plugin: () => Plugin,
+  Input: () => Input,
   NO_RESULTS: () => NO_RESULTS,
-  Input: () => Input
+  Plugin: () => Plugin,
+  WebSearchTool: () => exports_websearch2,
+  description: () => description,
+  name: () => name
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema, Semaphore } from "effect";
@@ -43,7 +43,7 @@ var Plugin = {
     const permission = yield* exports_permission.Service;
     const forms = yield* exports_form.Service;
     const websearch = yield* exports_websearch.Service;
-    yield* ctx.tool.transform((draft) => draft.add({
+    yield* ctx.tool.transform((editor) => editor.add({
       name,
       options: { codemode: false },
       description,

package/dist/chunks/{websearch-rahat93a.js → event-logger-rahat93a.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./websearch-k3e42drn.js";
+} from "./event-logger-k3e42drn.js";
 
 // src/ripgrep/binary.ts
 import path from "path";

package/dist/chunks/{websearch-8g883nkb.js → event-logger-rezbca9p.js}

@@ -1,21 +1,21 @@
 import {
   mapOpenAICompatibleFinishReason
-} from "./websearch-0cgt0xh2.js";
+} from "./event-logger-0cgt0xh2.js";
 import {
-  getResponseMetadata
-} from "./websearch-bbqs2y60.js";
+  prepareTools
+} from "./event-logger-ezs3tagn.js";
 import {
   openaiCompatibleProviderOptions
-} from "./websearch-a02svayp.js";
-import {
-  prepareTools
-} from "./websearch-ezs3tagn.js";
+} from "./event-logger-a02svayp.js";
 import {
   convertToOpenAICompatibleChatMessages
-} from "./websearch-brsh5f65.js";
+} from "./event-logger-brsh5f65.js";
+import {
+  getResponseMetadata
+} from "./event-logger-bbqs2y60.js";
 import {
   defaultOpenAICompatibleErrorStructure
-} from "./websearch-1wcz8fvj.js";
+} from "./event-logger-1wcz8fvj.js";
 
 // src/github-copilot/chat/openai-compatible-chat-language-model.ts
 import {

package/dist/chunks/{websearch-emhmd4ee.js → event-logger-rg8m7c20.js}

@@ -1,33 +1,33 @@
 import {
   exports_bus
-} from "./websearch-cat9v99r.js";
+} from "./event-logger-vw7aptj1.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/form.ts
 var exports_form = {};
 __export(exports_form, {
-  validateFields: () => validateFields,
-  validateAnswer: () => validateAnswer,
-  node: () => node,
-  layer: () => layer,
-  When: () => When,
-  State: () => State,
-  Service: () => Service,
-  Reply: () => Reply,
-  NotFoundError: () => NotFoundError,
-  InvalidFormError: () => InvalidFormError,
-  InvalidAnswerError: () => InvalidAnswerError,
-  Info: () => Info,
-  ID: () => ID,
-  Form: () => exports_form,
-  Fields: () => Fields,
-  Field: () => Field,
-  Event: () => Event,
-  Answer: () => Answer,
+  AlreadyExistsError: () => AlreadyExistsError,
   AlreadySettledError: () => AlreadySettledError,
-  AlreadyExistsError: () => AlreadyExistsError
+  Answer: () => Answer,
+  Event: () => Event,
+  Field: () => Field,
+  Fields: () => Fields,
+  Form: () => exports_form,
+  ID: () => ID,
+  Info: () => Info,
+  InvalidAnswerError: () => InvalidAnswerError,
+  InvalidFormError: () => InvalidFormError,
+  NotFoundError: () => NotFoundError,
+  Reply: () => Reply,
+  Service: () => Service,
+  State: () => State,
+  When: () => When,
+  layer: () => layer,
+  node: () => node,
+  validateAnswer: () => validateAnswer,
+  validateFields: () => validateFields
 });
 import { Form } from "@opencode-ai/schema/form";
 import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";

package/dist/chunks/event-logger-rr7wbarq.js

@@ -0,0 +1,151 @@
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/codemode/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  CodeModeCatalog: () => exports_catalog,
+  Summary: () => Summary,
+  Tool: () => Tool,
+  namespaceLine: () => namespaceLine,
+  summarize: () => summarize
+});
+import { Schema } from "effect";
+var Tool = Schema.Struct({
+  type: Schema.Literal("tool"),
+  name: Schema.String,
+  description: Schema.String,
+  signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Boolean)
+});
+var Listing = Schema.Struct({
+  path: Schema.String,
+  line: Schema.String
+});
+var NamespaceSummary = Schema.Struct({
+  name: Schema.String,
+  description: Schema.optionalKey(Schema.String),
+  count: Schema.Number,
+  entries: Schema.Array(Listing)
+});
+var Summary = Schema.Struct({
+  total: Schema.Number,
+  shown: Schema.Number,
+  namespaces: Schema.Array(NamespaceSummary)
+});
+var DESCRIPTION_LIMIT = 120;
+var CHARACTERS_PER_TOKEN = 4;
+var INLINE_BUDGET = 2000;
+function summarize(inventory, options = {}) {
+  const budget = options.budget ?? INLINE_BUDGET;
+  const flattened = flatten(inventory.tools);
+  const namespaces = [...Map.groupBy(flattened.tools, (tool) => tool.path.split(".", 1)[0] ?? tool.path)].sort(([left], [right]) => {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    return 0;
+  }).map(([name, namespaceEntries]) => {
+    const description = flattened.namespaces.get(name)?.description;
+    const listings = namespaceEntries.map((entry) => {
+      const firstLine = entry.description.split(`
+`, 1)[0]?.trim() ?? "";
+      const description2 = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description2.length === 0 ? "" : ` // ${description2}`;
+      return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
+    }).toSorted((left, right) => {
+      if (left.path < right.path)
+        return -1;
+      if (left.path > right.path)
+        return 1;
+      return 0;
+    });
+    const ranked = rankListings(listings);
+    const pinned = new Set(namespaceEntries.filter((entry) => entry.pinned).map((entry) => listings.find((listing) => listing.path === entry.path)).filter((listing) => listing !== undefined));
+    return {
+      name,
+      ...description === undefined ? {} : { description },
+      listings,
+      selectionOrder: ranked.filter((candidate) => !pinned.has(candidate.listing)),
+      selectedListings: pinned,
+      selectionIndex: 0
+    };
+  });
+  const active = new Set(namespaces);
+  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: []
+  })), 0) - namespaces.flatMap((namespace) => namespace.listings.filter((listing) => namespace.selectedListings.has(listing))).reduce((total, listing) => total + cost(listing.line), 0);
+  while (active.size > 0) {
+    for (const namespace of active) {
+      const candidate = namespace.selectionOrder[namespace.selectionIndex];
+      if (!candidate || candidate.cost > remaining) {
+        active.delete(namespace);
+        continue;
+      }
+      namespace.selectedListings.add(candidate.listing);
+      namespace.selectionIndex += 1;
+      remaining -= candidate.cost;
+      if (namespace.selectionIndex === namespace.selectionOrder.length)
+        active.delete(namespace);
+    }
+  }
+  const namespaceSummaries = namespaces.map((namespace) => ({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing))
+  }));
+  return {
+    total: flattened.tools.length,
+    shown: namespaceSummaries.reduce((total, namespace) => total + namespace.entries.length, 0),
+    namespaces: namespaceSummaries
+  };
+}
+function flatten(entries, path = []) {
+  const tools = [];
+  const namespaces = new Map;
+  for (const entry of entries) {
+    if (entry.type === "tool") {
+      tools.push({
+        type: "tool",
+        path: [...path, entry.name].join("."),
+        description: entry.description,
+        signature: entry.signature,
+        ...entry.pinned === undefined ? {} : { pinned: entry.pinned }
+      });
+      continue;
+    }
+    const next = [...path, entry.name];
+    namespaces.set(next.join("."), entry);
+    const nested = flatten(entry.tools, next);
+    tools.push(...nested.tools);
+    for (const [name, namespace] of nested.namespaces)
+      namespaces.set(name, namespace);
+  }
+  return { tools, namespaces };
+}
+function namespaceLine(namespace) {
+  const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
+  const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
+  return `- ${namespace.name} (${label})${namespace.description === undefined ? "" : ` // ${namespace.description}`}`;
+}
+function rankListings(listings) {
+  return listings.map((listing) => ({ listing, cost: cost(listing.line) })).toSorted((left, right) => {
+    if (left.cost !== right.cost)
+      return left.cost - right.cost;
+    if (left.listing.path < right.listing.path)
+      return -1;
+    if (left.listing.path > right.listing.path)
+      return 1;
+    return 0;
+  });
+}
+function cost(text) {
+  return Math.round(text.length / CHARACTERS_PER_TOKEN);
+}
+
+export { Tool, Summary, summarize, namespaceLine, exports_catalog };