@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19129

package/dist/chunks/schema-esv5q40e.js

@@ -1,18 +0,0 @@
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/plugin/service.ts
-var exports_service = {};
-__export(exports_service, {
-  Plugin: () => exports_service,
-  Service: () => Service,
-  awaitActivation: () => awaitActivation
-});
-import { Context } from "effect";
-
-class Service extends Context.Service()("@opencode/Plugin") {
-}
-var awaitActivation = Service.use((plugins) => plugins.awaitActivation);
-
-export { Service, awaitActivation, exports_service };

package/dist/chunks/schema-f3dqxhwr.js

@@ -1,24 +0,0 @@
-import {
-  exports_catalog
-} from "./schema-32ypdbhb.js";
-import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
-import {
-  exports_provider
-} from "./schema-68yag814.js";
-
-// src/plugin/provider/configured.ts
-import { Effect, Option } from "effect";
-var configuredSettings = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
-  const catalog = yield* exports_catalog.Service;
-  const current = (yield* catalog.provider.get(id))?.settings;
-  const service = yield* Effect.serviceOption(exports_config.Service);
-  const entries = Option.isSome(service) ? yield* service.value.entries() : [];
-  return foldSettings(entries, id, current);
-});
-function foldSettings(entries, id, initial) {
-  return entries.filter((entry) => entry.type === "document").reduce((settings, entry) => exports_provider.mergeOverlay(settings, entry.info.providers?.[id]?.settings), initial);
-}
-
-export { configuredSettings, foldSettings };

package/dist/chunks/schema-gc513wew.js

@@ -1,25 +0,0 @@
-import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/worktree/directory.ts
-var exports_directory = {};
-__export(exports_directory, {
-  DirectoryUnavailableError: () => DirectoryUnavailableError,
-  WorktreeDirectory: () => exports_directory,
-  canonical: () => canonical
-});
-import { Effect, Schema } from "effect";
-class DirectoryUnavailableError extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath }) {
-}
-var canonical = Effect.fnUntraced(function* (fs, input) {
-  const resolved = AbsolutePath.make(yield* fs.resolve(input));
-  if (!(yield* fs.isDir(resolved)))
-    return yield* new DirectoryUnavailableError({ directory: input });
-  return resolved;
-});
-
-export { DirectoryUnavailableError, canonical, exports_directory };

package/dist/chunks/schema-grfz4hhj.js

@@ -1,14 +0,0 @@
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/file.ts
-var exports_file = {};
-__export(exports_file, {
-  Diff: () => Diff,
-  File: () => exports_file
-});
-import { FileDiff } from "@opencode-ai/schema/file-diff";
-var Diff = FileDiff.Info;
-
-export { Diff, exports_file };

package/dist/chunks/schema-hs51b0fc.js

@@ -1,35 +0,0 @@
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/app.ts
-var exports_app = {};
-__export(exports_app, {
-  App: () => exports_app,
-  Metadata: () => Metadata,
-  configured: () => configured,
-  layer: () => layer,
-  make: () => make,
-  node: () => node,
-  useragent: () => useragent
-});
-import { Context, Layer } from "effect";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-var Metadata = Context.Reference("@opencode/App", {
-  defaultValue: () => make()
-});
-function make(input = {}) {
-  return {
-    name: input.name ?? "opencode",
-    version: input.version ?? "unknown",
-    channel: input.channel ?? "unknown"
-  };
-}
-function useragent(app) {
-  return `opencode/${app.channel}/${app.version}/${app.name}`;
-}
-var layer = (input) => Layer.succeed(Metadata, make(input));
-var configured = (input) => makeGlobalNode({ service: Metadata, layer: layer(input), deps: [] });
-var node = configured();
-
-export { Metadata, make, useragent, layer, configured, node, exports_app };

package/dist/chunks/schema-hy5n5jcn.js

@@ -1,13 +0,0 @@
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/plugin/promise.ts
-var exports_promise = {};
-__export(exports_promise, {
-  PluginPromise: () => exports_promise,
-  fromPromise: () => fromPromise
-});
-import { fromPromise } from "@opencode-ai/plugin/promise/adapter";
-
-export { exports_promise, fromPromise };

package/dist/chunks/schema-j07kk359.js

@@ -1,21 +0,0 @@
-// src/schema.ts
-import { Schema } from "effect";
-import {
-  AbsolutePath,
-  DateTimeUtcFromMillis,
-  NonNegativeInt,
-  optional,
-  PositiveInt,
-  RelativePath,
-  statics
-} from "@opencode-ai/schema/schema";
-function Newtype() {
-  return (tag, schema) => {
-    class Base {
-    }
-    Object.setPrototypeOf(Base, schema.pipe(Schema.brand(tag)));
-    return Base;
-  };
-}
-
-export { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics, Newtype };

package/dist/chunks/schema-jgzett5g.js

@@ -1,151 +0,0 @@
-import {
-  CredentialTable
-} from "./schema-mf0hyk7z.js";
-import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
-import {
-  exports_database
-} from "./schema-8scqw7rh.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/credential.ts
-var exports_credential = {};
-__export(exports_credential, {
-  Credential: () => exports_credential,
-  Event: () => Event,
-  ID: () => ID,
-  Info: () => Info,
-  Key: () => Key,
-  OAuth: () => OAuth,
-  Service: () => Service,
-  Value: () => Value,
-  node: () => node
-});
-import { asc, desc, eq } from "drizzle-orm";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Credential } from "@opencode-ai/schema/credential";
-import { Integration } from "@opencode-ai/schema/integration";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-var ID = Credential.ID;
-var OAuth = Credential.OAuth;
-var Key = Credential.Key;
-var Value = Credential.Value;
-var Event = Credential.Event;
-
-class Info extends Schema.Class("Credential.Info")({
-  id: ID,
-  integrationID: Integration.ID,
-  label: Schema.String,
-  value: Value
-}) {
-}
-
-class Service extends Context.Service()("@opencode/Credential") {
-}
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
-  const decode = Schema.decodeUnknownSync(Value);
-  const stored = (row) => {
-    if (!row.integration_id)
-      return;
-    return new Info({
-      id: row.id,
-      integrationID: row.integration_id,
-      label: row.label,
-      value: decode(row.value)
-    });
-  };
-  const storedRows = (rows) => rows.flatMap((row) => {
-    const credential = stored(row);
-    return credential ? [credential] : [];
-  });
-  return Service.of({
-    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    get: Effect.fn("Credential.get")(function* (id) {
-      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      return row ? stored(row) : undefined;
-    }),
-    create: Effect.fn("Credential.create")(function* (input) {
-      const credential = new Info({
-        id: ID.create(),
-        integrationID: input.integrationID,
-        label: input.label ?? "default",
-        value: input.value
-      });
-      yield* db.transaction((tx) => Effect.gen(function* () {
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
-        yield* tx.insert(CredentialTable).values({
-          id: credential.id,
-          integration_id: credential.integrationID,
-          label: credential.label,
-          value: credential.value,
-          active: true
-        }).run();
-      })).pipe(Effect.orDie);
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      yield* bus.publish(Event.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
-      return credential;
-    }),
-    activate: Effect.fn("Credential.activate")(function* (id) {
-      const integrationID = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential?.integration_id)
-          return;
-        const active = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (active?.id === id)
-          return;
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-        yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, id)).run();
-        return credential.integration_id;
-      })).pipe(Effect.orDie);
-      if (integrationID)
-        yield* bus.publish(Event.Switched, { integrationID, credentialID: id }, { global: true });
-    }),
-    update: Effect.fn("Credential.update")(function* (id, updates) {
-      if (updates.label === undefined && updates.value === undefined)
-        return;
-      const credential = yield* db.select({ integrationID: CredentialTable.integration_id, label: CredentialTable.label }).from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      if (!credential?.integrationID)
-        return;
-      if (updates.label === credential.label && updates.value === undefined)
-        return;
-      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
-      if (updates.label !== undefined && updates.label !== credential.label)
-        yield* bus.publish(Event.Updated, {}, { global: true });
-    }),
-    remove: Effect.fn("Credential.remove")(function* (id) {
-      const removed = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential)
-          return;
-        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get() : undefined;
-        yield* tx.delete(CredentialTable).where(eq(CredentialTable.id, id)).run();
-        if (!credential.integration_id || active?.id !== id)
-          return { switched: false };
-        const replacement = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (replacement) {
-          yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-          yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, replacement.id)).run();
-        }
-        return {
-          switched: true,
-          integrationID: credential.integration_id,
-          credentialID: replacement?.id ?? null
-        };
-      })).pipe(Effect.orDie);
-      if (!removed)
-        return;
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      if (removed.switched)
-        yield* bus.publish(Event.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
-    })
-  });
-}));
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node, exports_bus.node] });
-
-export { ID, OAuth, Key, Value, Event, Info, Service, node, exports_credential };

package/dist/chunks/schema-jrpamtww.js

@@ -1,39 +0,0 @@
-import {
-  exports_service as exports_service2
-} from "./schema-esv5q40e.js";
-import {
-  exports_service
-} from "./schema-6bxzghb6.js";
-import {
-  exports_command
-} from "./schema-j8tff6ta.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/session/command.ts
-var exports_command2 = {};
-__export(exports_command2, {
-  SessionCommand: () => exports_command2,
-  execute: () => execute
-});
-import { Effect } from "effect";
-var execute = Effect.fn("SessionCommand.execute")(function* (input) {
-  const instances = yield* exports_service.Service;
-  const commands = yield* exports_service2.awaitActivation.pipe(Effect.andThen(exports_command.Service), instances.provide(input.session));
-  yield* commands.execute({
-    name: input.command,
-    invocation: {
-      sessionID: input.session.id,
-      prompt: {
-        text: input.text,
-        files: input.files,
-        agents: input.agents,
-        skills: input.skills
-      },
-      delivery: input.delivery ?? "steer"
-    }
-  });
-});
-
-export { execute, exports_command2 as exports_command };

package/dist/chunks/schema-k030pceh.js

@@ -1,22 +0,0 @@
-import {
-  exports_firecrawl
-} from "./schema-4w0ckvbq.js";
-import {
-  exports_exa
-} from "./schema-e0n16vwa.js";
-import {
-  exports_tavily
-} from "./schema-pves38xm.js";
-import {
-  exports_parallel
-} from "./schema-ntev5d3k.js";
-
-// src/plugin/websearch/index.ts
-var WebSearchPlugins = [
-  exports_exa.Plugin,
-  exports_firecrawl.Plugin,
-  exports_parallel.Plugin,
-  exports_tavily.Plugin
-];
-
-export { WebSearchPlugins };

package/dist/chunks/schema-m7jtgrng.js

@@ -1,31 +0,0 @@
-import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/project/schema.ts
-var exports_schema = {};
-__export(exports_schema, {
-  Current: () => Current,
-  Event: () => Event,
-  ID: () => ID,
-  Info: () => Info,
-  ProjectSchema: () => exports_schema,
-  UpdateInput: () => UpdateInput,
-  Vcs: () => Vcs
-});
-import { Schema } from "effect";
-import { Project } from "@opencode-ai/schema/project";
-var ID = Project.ID;
-var Current = Project.Current;
-var Info = Project.Info;
-var UpdateInput = Project.UpdateInput;
-var Event = Project.Event;
-var Vcs = Schema.Struct({
-  type: Project.Vcs,
-  store: AbsolutePath
-});
-
-export { ID, Current, Info, UpdateInput, Event, Vcs, exports_schema };

package/dist/chunks/schema-mw1qz6py.js

@@ -1,33 +0,0 @@
-import {
-  exports_service as exports_service2
-} from "./schema-esv5q40e.js";
-import {
-  exports_service
-} from "./schema-6bxzghb6.js";
-import {
-  exports_skill
-} from "./schema-tbzs2pmr.js";
-import {
-  SkillNotFoundError
-} from "./schema-2sqw2jjm.js";
-import {
-  __export
-} from "./schema-vpjkya7h.js";
-
-// src/session/skill.ts
-var exports_skill2 = {};
-__export(exports_skill2, {
-  SessionSkill: () => exports_skill2,
-  get: () => get
-});
-import { Effect } from "effect";
-var get = Effect.fn("SessionSkill.get")(function* (input) {
-  const instances = yield* exports_service.Service;
-  const skills = yield* exports_service2.awaitActivation.pipe(Effect.andThen(exports_skill.Service), instances.provide(input.session));
-  const skill = yield* skills.get(input.skill);
-  if (!skill)
-    return yield* new SkillNotFoundError({ skill: input.skill });
-  return skill;
-});
-
-export { get, exports_skill2 as exports_skill };

package/dist/chunks/schema-p0ye3rhn.js

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