@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-0mqwymb3.js

@@ -0,0 +1,90 @@
+import {
+  exports_model_resolver
+} from "./location-mutation-rkgk5nqx.js";
+import {
+  exports_schema
+} from "./location-mutation-y8rs54ne.js";
+import {
+  exports_catalog
+} from "./location-mutation-5gvndtda.js";
+import {
+  ID,
+  Ref
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/runner/model.ts
+var exports_model = {};
+__export(exports_model, {
+  resolved: () => resolved,
+  node: () => node,
+  VariantUnavailableError: () => VariantUnavailableError,
+  UnsupportedPackageError: () => UnsupportedPackageError,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError,
+  SessionRunnerModel: () => exports_model,
+  Service: () => Service,
+  ModelUnavailableError: () => ModelUnavailableError,
+  ModelNotSelectedError: () => ModelNotSelectedError
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ModelNotSelectedError extends Schema.TaggedErrorClass()("SessionRunnerModel.ModelNotSelectedError", { sessionID: exports_schema.ID }) {
+  get message() {
+    return `No model is available for session ${this.sessionID}`;
+  }
+}
+
+class ModelUnavailableError extends Schema.TaggedErrorClass()("SessionRunnerModel.ModelUnavailableError", { providerID: exports_provider.ID, modelID: ID }) {
+  get message() {
+    if (this.providerID === "azure-cognitive-services")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`;
+    if (this.providerID === "google-vertex-anthropic")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use google-vertex/${this.modelID} instead.`;
+    return `Model unavailable: ${this.providerID}/${this.modelID}`;
+  }
+}
+var VariantUnavailableError = exports_model_resolver.VariantUnavailableError;
+var UnsupportedPackageError = exports_model_resolver.UnsupportedPackageError;
+var UnresolvedProviderVariablesError = exports_model_resolver.UnresolvedProviderVariablesError;
+
+class Service extends Context.Service()("@opencode/SessionRunnerModel") {
+}
+var resolved = (model, options) => ({
+  model,
+  ref: Ref.make({
+    id: ID.make(model.id),
+    providerID: exports_provider.ID.make(model.provider),
+    ...options.variant === undefined ? {} : { variant: options.variant }
+  }),
+  capabilities: options.capabilities,
+  cost: options.cost
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const catalog = yield* exports_catalog.Service;
+  const resolver = yield* exports_model_resolver.Service;
+  return Service.of({
+    resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session) {
+      if (!session.model) {
+        const resolved2 = yield* resolver.resolve();
+        if (resolved2)
+          return resolved2;
+        return yield* new ModelNotSelectedError({ sessionID: session.id });
+      }
+      const selected = (yield* catalog.model.available()).find((model) => model.providerID === session.model?.providerID && model.id === session.model.id);
+      if (!selected)
+        return yield* new ModelUnavailableError({
+          providerID: session.model.providerID,
+          modelID: session.model.id
+        });
+      return yield* resolver.resolveModel(selected, session.model.variant);
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_catalog.node, exports_model_resolver.node] });
+
+export { ModelNotSelectedError, ModelUnavailableError, VariantUnavailableError, UnsupportedPackageError, UnresolvedProviderVariablesError, Service, resolved, node, exports_model };

package/dist/chunks/location-mutation-0ms0v4tv.js

@@ -0,0 +1,120 @@
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  node: () => node,
+  defaultID: () => defaultID,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  Color: () => Color,
+  Agent: () => exports_agent
+});
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Array, Context, Effect, Layer } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/agent";
+var SHELL_OUTPUT_GLOB = (data) => path.join(data, "shell", "*", "*");
+var TOOL_OUTPUT_GLOB = (data) => path.join(data, "tool-output", "*");
+var ID = Agent.ID;
+var Name = Agent.Name;
+var defaultID = ID.make("build");
+var Color = Agent.Color;
+var Info = Agent.Info;
+
+class Service extends Context.Service()("@opencode/Agent") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const global = yield* Global.Service;
+  const permissions = [
+    { action: "external_directory", resource: SHELL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: TOOL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" }
+  ];
+  const state = exports_state.create({
+    name: "agent",
+    initial: () => ({ agents: new Map }),
+    draft: (draft) => ({
+      list: () => Array.fromIterable(draft.agents.values()),
+      get: (id) => draft.agents.get(id),
+      default: (id) => {
+        draft.default = id;
+      },
+      update: (id, fn) => {
+        const defaults = Info.default(id);
+        const current = draft.agents.get(id) ?? {
+          ...defaults,
+          permissions: [...defaults.permissions, ...permissions]
+        };
+        if (!draft.agents.has(id))
+          draft.agents.set(id, current);
+        fn(current);
+        current.id = id;
+      },
+      remove: (id) => {
+        draft.agents.delete(id);
+      }
+    }),
+    finalize: () => bus.publish(Agent.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const selectable = (agent) => agent && agent.mode !== "subagent" && !agent.hidden ? agent : undefined;
+  const selectedDefault = () => {
+    const data = state.get();
+    const configured = data.default ? selectable(data.agents.get(data.default)) : undefined;
+    if (configured)
+      return configured;
+    const build = selectable(data.agents.get(ID.make("build")));
+    if (build)
+      return build;
+    for (const agent of data.agents.values()) {
+      const fallback = selectable(agent);
+      if (fallback)
+        return fallback;
+    }
+  };
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Agent.get")(function* (id) {
+      return state.get().agents.get(id);
+    }),
+    resolve: Effect.fn("Agent.resolve")(function* (id) {
+      if (id !== undefined)
+        return state.get().agents.get(ID.make(id));
+      return selectedDefault();
+    }),
+    select: Effect.fn("Agent.select")(function* (id) {
+      if (id !== undefined) {
+        const selected = ID.make(id);
+        return { id: selected, info: state.get().agents.get(selected) };
+      }
+      const info = selectedDefault();
+      return { id: info?.id ?? defaultID, info };
+    }),
+    list: Effect.fn("Agent.list")(function* () {
+      const agents = Array.fromIterable(state.get().agents.values());
+      const selected = selectedDefault();
+      if (!selected)
+        return agents;
+      return [selected, ...agents.filter((agent) => agent.id !== selected.id)];
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, Global.node] });
+
+export { ID, Name, defaultID, Color, Info, Service, node, exports_agent, Event };

package/dist/chunks/location-mutation-0n6dmnq5.js

@@ -0,0 +1,115 @@
+import {
+  exports_snapshot
+} from "./location-mutation-a6xxb9cb.js";
+import {
+  exports_message
+} from "./location-mutation-25pxtba7.js";
+import {
+  SessionMessageTable
+} from "./location-mutation-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+import {
+  exports_schema
+} from "./location-mutation-y8rs54ne.js";
+import {
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  stage: () => stage,
+  commit: () => commit,
+  clear: () => clear,
+  SessionRevert: () => exports_revert,
+  MessageNotFoundError: () => MessageNotFoundError
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+class MessageNotFoundError extends Schema.TaggedErrorClass()("Session.MessageNotFoundError", {
+  sessionID: exports_schema.ID,
+  messageID: exports_message.ID
+}) {
+}
+var plan = Effect.fn("SessionRevert.plan")(function* (input) {
+  const db = (yield* exports_database.Service).db;
+  const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError(input);
+  const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.type, "assistant"), gt(SessionMessageTable.seq, boundary.seq))).orderBy(asc(SessionMessageTable.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(exports_message.Info);
+  const files = new Map;
+  for (const row of rows) {
+    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie);
+    if (message.type !== "assistant" || !message.snapshot?.start)
+      continue;
+    for (const file of message.snapshot.files ?? [])
+      if (!files.has(file))
+        files.set(file, exports_snapshot.ID.make(message.snapshot.start));
+  }
+  return files;
+});
+var stage = Effect.fn("SessionRevert.stage")(function* (input) {
+  const snapshot = yield* exports_snapshot.Service;
+  const bus = yield* exports_bus.Service;
+  const original = input.session.revert?.snapshot ? exports_snapshot.ID.make(input.session.revert.snapshot) : yield* snapshot.capture();
+  const next = yield* plan({ sessionID: input.session.id, messageID: input.messageID });
+  const restore = new Map;
+  if (original) {
+    for (const file of input.session.revert?.files ?? [])
+      restore.set(RelativePath.make(file.file), original);
+  }
+  if (input.files !== false)
+    for (const [file, tree] of next)
+      restore.set(file, tree);
+  if (restore.size)
+    yield* snapshot.restore({ files: restore });
+  const paths = input.files === false ? [] : Array.from(next.keys());
+  const files = original ? yield* snapshot.diff({ from: original, to: (yield* snapshot.capture()) ?? original, paths }) : [];
+  const revert = {
+    messageID: input.messageID,
+    snapshot: original,
+    files
+  };
+  yield* bus.publish(SessionEvent.RevertEvent.Staged, {
+    sessionID: input.session.id,
+    revert
+  });
+  return revert;
+});
+var clear = Effect.fn("SessionRevert.clear")(function* (session) {
+  if (!session.revert)
+    return;
+  const snapshot = yield* exports_snapshot.Service;
+  const original = session.revert.snapshot ? exports_snapshot.ID.make(session.revert.snapshot) : undefined;
+  if (original)
+    yield* snapshot.restore({
+      files: new Map((session.revert.files ?? []).map((file) => [RelativePath.make(file.file), original]))
+    });
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Cleared, {
+    sessionID: session.id
+  });
+});
+var commit = Effect.fn("SessionRevert.commit")(function* (session) {
+  if (!session.revert)
+    return;
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+
+export { MessageNotFoundError, stage, clear, commit, exports_revert };