@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-hqdypqbx.js

@@ -0,0 +1,139 @@
+import {
+  exports_internal
+} from "./location-mutation-3hxg02dc.js";
+import {
+  exports_source
+} from "./location-mutation-e3x7e18f.js";
+import {
+  exports_sdk
+} from "./location-mutation-qjc2dhc6.js";
+import {
+  exports_promise
+} from "./location-mutation-5vcssjzn.js";
+import {
+  exports_plugin
+} from "./location-mutation-trcj3z49.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  node: () => node,
+  layer: () => layer,
+  Service: () => Service,
+  PluginSupervisor: () => exports_supervisor
+});
+import { Event } from "@opencode-ai/schema/config";
+import { Context, Deferred, Effect, Layer, Schema, Stream } from "effect";
+import path from "path";
+import { pathToFileURL } from "url";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Npm } from "@opencode-ai/util/npm";
+import { importModule } from "@opencode-ai/util/runtime-import";
+var PluginModule = 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")
+    })
+  ])
+});
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (pre, post, operations) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      plugins().filter((plugin2) => matches(operation.target, plugin2.id)).forEach((plugin2) => enabled.delete(plugin2.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin2) => matches(operation.target, plugin2.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin2) => enabled.add(plugin2.id));
+      continue;
+    }
+    const plugin = yield* load(operation).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(Effect.as(undefined))));
+    if (!plugin)
+      continue;
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  return [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...Array.from(packages.values()).filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id))
+  ];
+});
+var load = Effect.fn("PluginSupervisor.load")(function* (operation) {
+  const npm = yield* Npm.Service;
+  const entrypoint = path.isAbsolute(operation.target) ? pathToFileURL(operation.target).href : (yield* npm.add(operation.target, { subpaths: ["server", ""] })).entrypoint;
+  if (!entrypoint)
+    return;
+  const source = operation.mtime === undefined ? entrypoint : typeof Bun !== "undefined" ? `${operation.target.replaceAll("\\", "/")}?mtime=${operation.mtime}` : `${entrypoint}?mtime=${operation.mtime}`;
+  yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source });
+  const mod = yield* Effect.promise(() => importModule(source));
+  const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default;
+  const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  return {
+    id: plugin.id,
+    version: JSON.stringify(operation),
+    effect: (host) => plugin.effect({ ...host, options: operation.options })
+  };
+});
+
+class Service extends Context.Service()("@opencode/PluginSupervisor") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const registry = yield* exports_plugin.Service;
+  const sdk = yield* exports_sdk.Service;
+  const sources = yield* exports_source.Service;
+  const bus = yield* exports_bus.Service;
+  const ready = { current: yield* Deferred.make() };
+  let observed = 0;
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const internal = yield* exports_internal.list();
+    const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()];
+    const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }));
+    const operations = yield* sources.operations();
+    const plugins = yield* resolve(pre, post, operations);
+    yield* registry.activate(plugins);
+  });
+  const updates = Stream.merge(sources.changes(), bus.subscribe([Event.Updated, exports_sdk.Updated])).pipe(Stream.mapEffect(() => Effect.gen(function* () {
+    observed++;
+    if (yield* Deferred.isDone(ready.current))
+      ready.current = yield* Deferred.make();
+    return observed;
+  })));
+  yield* Stream.concat(Stream.succeed(0), updates).pipe(Stream.buffer({ capacity: 1, strategy: "sliding" }), Stream.debounce("100 millis"), Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate();
+    if (observed === target)
+      yield* Deferred.succeed(ready.current, undefined);
+  }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  return Service.of({ flush: Effect.suspend(() => Deferred.await(ready.current)) });
+}));
+var nodeDeps = [
+  exports_plugin.node,
+  exports_sdk.node,
+  exports_source.node,
+  exports_bus.node,
+  Npm.node,
+  exports_internal.requirements
+];
+var node = makeLocationNode({ service: Service, layer, deps: nodeDeps });
+
+export { Service, layer, node, exports_supervisor };

package/dist/chunks/location-mutation-hqew6wwe.js

@@ -0,0 +1,113 @@
+import {
+  toLLMMessages
+} from "./location-mutation-6jtjggv5.js";
+import {
+  exports_context
+} from "./location-mutation-33c4tp6x.js";
+import {
+  exports_system_prompt
+} from "./location-mutation-v80zsxnb.js";
+import {
+  exports_model_headers
+} from "./location-mutation-1xksxgzs.js";
+import {
+  exports_prompt_cache_key
+} from "./location-mutation-52jzav25.js";
+import {
+  exports_generate
+} from "./location-mutation-xgv25zxy.js";
+import {
+  exports_model
+} from "./location-mutation-0mqwymb3.js";
+import {
+  llmClient
+} from "./location-mutation-j1a5h53y.js";
+import {
+  exports_history
+} from "./location-mutation-04gk6yaw.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_hooks
+} from "./location-mutation-0dwyqmzq.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/generate-node.ts
+var exports_generate_node = {};
+__export(exports_generate_node, {
+  node: () => node,
+  layer: () => layer,
+  SessionGenerateNode: () => exports_generate_node
+});
+import { LLM, LLMClient, Message, SystemPart } from "@opencode-ai/ai";
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var layer = Layer.effect(exports_generate.Service, Effect.gen(function* () {
+  const context = yield* exports_context.Service;
+  const database = yield* exports_database.Service;
+  const hooks = yield* exports_hooks.Service;
+  const llm = yield* LLMClient.Service;
+  const models = yield* exports_model.Service;
+  const app = yield* exports_app.Metadata;
+  return exports_generate.Service.of({
+    generate: Effect.fn("SessionGenerate.generate")(function* (input) {
+      const selection = yield* context.select(input.sessionID);
+      const model = yield* models.resolve(selection.session);
+      const history = yield* exports_history.preview(database.db, selection.session.id, selection.instructions);
+      const providerMetadataKey = model.model.route.providerMetadataKey ?? model.model.provider;
+      const tools = selection.tools;
+      const toolDefinitions = tools.definitions;
+      const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]));
+      const contextEvent = yield* hooks.trigger("session", "context", {
+        sessionID: selection.session.id,
+        agent: selection.agent.id,
+        model: model.ref,
+        system: [
+          selection.agent.info.system ? selection.agent.info.system : exports_system_prompt.make(toolDefinitions.map((tool) => tool.name)),
+          history.initial
+        ].filter((part) => part.length > 0).map(SystemPart.make),
+        messages: [
+          ...toLLMMessages(history.messages, model.ref, providerMetadataKey),
+          ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+          Message.user(input.prompt)
+        ],
+        tools: Object.fromEntries(toolDefinitions.map((tool) => [
+          tool.name,
+          { description: tool.description, input: { ...tool.inputSchema } }
+        ]))
+      });
+      const hookedTools = Object.entries(contextEvent.tools).flatMap(([name, tool]) => {
+        const registered = toolsByName.get(name);
+        return registered ? [Object.assign({}, registered, { description: tool.description, inputSchema: tool.input })] : [];
+      });
+      yield* Effect.logInfo("sending session generation request", {
+        sessionID: selection.session.id,
+        providerID: model.ref.providerID,
+        modelID: model.ref.id
+      });
+      const response = yield* llm.generate(LLM.request({
+        model: model.model,
+        http: { headers: exports_model_headers.make(selection.session, app) },
+        promptCacheKey: exports_prompt_cache_key.make(selection.session.id),
+        system: contextEvent.system,
+        messages: contextEvent.messages,
+        tools: hookedTools
+      }));
+      yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+      return response.text;
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: exports_generate.Service,
+  layer,
+  deps: [exports_context.node, exports_database.node, exports_hooks.node, exports_model.node, exports_app.node, llmClient]
+});
+
+export { layer, node, exports_generate_node };

package/dist/chunks/location-mutation-hqvsy57f.js

@@ -0,0 +1,65 @@
+import {
+  llmClient
+} from "./location-mutation-j1a5h53y.js";
+import {
+  exports_model_resolver
+} from "./location-mutation-rkgk5nqx.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  node: () => node,
+  layer: () => layer,
+  UnavailableError: () => UnavailableError,
+  Service: () => Service,
+  ModelSelectionError: () => ModelSelectionError,
+  Generate: () => exports_generate
+});
+import { LLM, LLMClient } from "@opencode-ai/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+class ModelSelectionError extends Schema.TaggedErrorClass()("Generate.ModelSelectionError", { message: Schema.String }) {
+}
+
+class UnavailableError extends Schema.TaggedErrorClass()("Generate.UnavailableError", {
+  message: Schema.String,
+  service: Schema.optional(Schema.String)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Generate") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const llm = yield* LLMClient.Service;
+  const resolver = yield* exports_model_resolver.Service;
+  const runText = Effect.fn("Generate.text")(function* (input) {
+    const resolved = yield* resolver.resolve(input.model).pipe(Effect.catchTags({
+      "SessionRunnerModel.VariantUnavailableError": (error) => input.model ? new ModelSelectionError({ message: error.message }) : new UnavailableError({ message: error.message, service: error.providerID }),
+      "SessionRunnerModel.UnsupportedPackageError": (error) => input.model ? new ModelSelectionError({ message: error.message }) : new UnavailableError({ message: error.message, service: error.providerID }),
+      "SessionRunnerModel.UnresolvedProviderVariablesError": (error) => input.model ? new ModelSelectionError({ message: error.message }) : new UnavailableError({ message: error.message, service: error.providerID })
+    }));
+    if (!resolved)
+      return yield* new ModelSelectionError({
+        message: input.model ? `Model unavailable: ${input.model.providerID}/${input.model.id}` : "No model specified and no supported model is available"
+      });
+    const response = yield* llm.generate(LLM.request({ model: resolved.model, prompt: input.prompt })).pipe(Effect.mapError((error) => new UnavailableError({
+      message: error.message,
+      service: resolved.ref.providerID
+    })));
+    return response.text;
+  });
+  const text = (input) => runText(input).pipe(Effect.catchTag("Integration.Authorization", () => new UnavailableError({
+    message: "Generation credentials are unavailable"
+  })));
+  return Service.of({ text });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_model_resolver.node, llmClient]
+});
+
+export { ModelSelectionError, UnavailableError, Service, layer, node, exports_generate };

package/dist/chunks/location-mutation-hzeg9cfr.js

@@ -0,0 +1,49 @@
+// src/util/error.ts
+import { Schema } from "effect";
+
+class NamedError extends Error {
+  static hasName(error, name) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === name;
+  }
+  static create(name, data) {
+    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
+  }
+  static createSchemaClass(name, data) {
+    const schema = Schema.Struct({
+      name: Schema.Literal(name),
+      data
+    }).annotate({ identifier: name });
+    const result = class extends NamedError {
+      data;
+      static Schema = schema;
+      static EffectSchema = schema;
+      static tag = name;
+      name = name;
+      constructor(data2, options) {
+        super(name, options);
+        this.data = data2;
+        this.name = name;
+      }
+      static isInstance(input) {
+        return NamedError.hasName(input, name);
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = NamedError.create("UnknownError", {
+    message: Schema.String,
+    ref: Schema.optional(Schema.String)
+  });
+}
+
+export { NamedError };

package/dist/chunks/location-mutation-j07kk359.js

@@ -0,0 +1,21 @@
+// 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/location-mutation-j0ksmf2f.js

@@ -0,0 +1,72 @@
+import {
+  exports_drizzle
+} from "./location-mutation-fvhse3q1.js";
+import {
+  exports_migration
+} from "./location-mutation-hj7sdrcm.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  node: () => node,
+  layerFromClient: () => layerFromClient,
+  layer: () => layer,
+  configuredClient: () => configuredClient,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  Database: () => exports_database
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode-ai/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var makeDatabase = exports_drizzle.makeWithDefaults();
+var Options = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  yield* exports_migration.apply(db);
+  return { db };
+}).pipe(Effect.orDie));
+function layer(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename2) => layerFromClient.pipe(Layer.provide(sqliteLayer({ filename: filename2 })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient = databaseLayer;
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] });
+}
+function configuredClient(client) {
+  return makeGlobalNode({
+    service: Service,
+    layer: layerFromClient.pipe(Layer.provide(client)),
+    deps: [Global.node]
+  });
+}
+var node = configured({ path: ":memory:" });
+
+export { Options, Service, layer, layerFromClient, configured, configuredClient, node, exports_database };

package/dist/chunks/location-mutation-j1a5h53y.js

@@ -0,0 +1,30 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/effect/app-node-platform.ts
+var exports_app_node_platform = {};
+__export(exports_app_node_platform, {
+  webSocketConstructor: () => webSocketConstructor,
+  requestExecutor: () => requestExecutor,
+  llmClient: () => llmClient,
+  LayerNodePlatform: () => exports_app_node_platform
+});
+import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route";
+import { NodeSocket } from "@effect/platform-node";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+var requestExecutor = makeGlobalNode({
+  service: RequestExecutor.Service,
+  layer: RequestExecutor.layer,
+  deps: [httpClient]
+});
+var llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] });
+var webSocketConstructor = makeGlobalNode({
+  service: Socket.WebSocketConstructor,
+  layer: NodeSocket.layerWebSocketConstructorWS,
+  deps: []
+});
+
+export { requestExecutor, llmClient, webSocketConstructor, exports_app_node_platform };

package/dist/chunks/location-mutation-j9xrabht.js

@@ -0,0 +1,72 @@
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/plan.ts
+var exports_plan = {};
+__export(exports_plan, {
+  Plugin: () => Plugin,
+  PlanPlugin: () => exports_plan
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var plan = exports_agent.ID.make("plan");
+var enter = `<system-reminder>
+You are in Plan mode. You are not allowed to edit or create files, and you may not ask a subagent to do that either.
+
+You are in Plan mode until the user switches agents. Plan mode is not changed by user intent, tone, or imperative language. If the user asks you to change files, do not edit. Tell them they need to switch agents.
+</system-reminder>`;
+var leave = `<system-reminder>
+You are NO LONGER in Plan mode. The previous Plan restrictions no longer apply. Any Plan mode instructions from earlier in this conversation are no longer active.
+</system-reminder>`;
+var Plugin = define({
+  id: "opencode.plan",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.agent.transform((draft) => {
+      draft.update(plan, (item) => {
+        item.name = exports_agent.Name.make("Plan");
+        item.description = "Read-only agent for exploring the codebase and planning work before implementation.";
+        item.mode = "primary";
+        item.permissions.push({ action: "question", resource: "*", effect: "allow" });
+      });
+    });
+    yield* ctx.tool.hook("execute.before", (event) => {
+      if (event.agent !== plan)
+        return Effect.void;
+      if (event.tool !== "edit" && event.tool !== "write" && event.tool !== "patch")
+        return Effect.void;
+      return new ToolFailure({
+        message: `Cannot use ${event.tool} in Plan mode. You are in a read-only mode and must not modify files.`
+      });
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "session.created" || event.type === "session.agent.selected"), Stream.runForEach((event) => {
+      const text = reminder(event);
+      if (!text)
+        return Effect.void;
+      return ctx.session.synthetic({
+        sessionID: event.data.sessionID,
+        text,
+        resume: false
+      }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to inject Plan mode reminder", { sessionID: event.data.sessionID, cause })));
+    }), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function reminder(event) {
+  if (event.type === "session.created") {
+    if (event.data.agent !== plan)
+      return;
+    return enter;
+  }
+  if (event.data.agent === event.data.previous)
+    return;
+  if (event.data.agent === plan)
+    return enter;
+  if (event.data.previous === plan)
+    return leave;
+}
+
+export { Plugin, exports_plan };