@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-pj7nypz0.js → command-b89m47td.js}

@@ -1,176 +1,190 @@
 import {
-  exports_command
-} from "./integration-fn8qccm8.js";
+  ID7,
+  Info9,
+  SessionSchema2
+} from "./command-5rw6je3s.js";
 import {
-  exports_session
-} from "./integration-pn89kfvv.js";
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  DestinationNotDirectoryError,
-  DestinationNotFoundError,
-  DestinationUnavailableError,
-  exports_move
-} from "./integration-d6yxznb3.js";
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
 import {
-  exports_generate
-} from "./integration-w2nd9bs6.js";
+  isSynced2,
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  exports_projector
-} from "./integration-a2y4sq9c.js";
+  Service69,
+  node72
+} from "./command-drn755cb.js";
 import {
-  exports_execution
-} from "./integration-nh84sznz.js";
+  Service33,
+  node35
+} from "./command-y092mk2a.js";
 import {
-  exports_inbox
-} from "./integration-d9nzfyee.js";
+  SessionEvent2
+} from "./command-mntxs535.js";
 import {
-  exports_instruction_entry
-} from "./integration-6yzp77jc.js";
+  SessionMessageTable2
+} from "./command-hrvm11jt.js";
 import {
-  exports_model_transport
-} from "./integration-rpa95wsa.js";
+  node34
+} from "./command-32m8x2r5.js";
 import {
-  exports_service
-} from "./integration-6bxzghb6.js";
+  current2
+} from "./command-g7csxrs7.js";
 import {
-  Slug
-} from "./integration-df3v2q6j.js";
+  snapshot2
+} from "./command-0yrmd491.js";
 import {
-  exports_job
-} from "./integration-bymgjy4k.js";
+  Slug2
+} from "./command-gebd4c9n.js";
 import {
-  llmClient
-} from "./integration-326j4s6w.js";
+  SessionAlreadyProjected2,
+  node24
+} from "./command-y5x79gk7.js";
 import {
-  exports_store
-} from "./integration-jwp0b78z.js";
+  Metadata2,
+  node81
+} from "./command-55yvdk0c.js";
 import {
-  exports_instruction_state
-} from "./integration-m3k5wttq.js";
+  NotFoundError6,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  ForkEmptyError2,
+  MessageDecodeError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  AttachmentError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2,
+  SkillNotFoundError2
+} from "./command-c28brx2k.js";
 import {
-  AttachmentError,
-  BusyError,
-  CompactionConflictError,
-  ForkEmptyError,
-  InboxConflictError,
-  MessageDecodeError,
-  MessageIncompleteError,
-  MessageNotAssistantError,
-  MessageNotFoundError,
-  MessageToolIncompleteError,
-  NotFoundError,
-  PromptConflictError,
-  SkillNotFoundError,
-  SyntheticConflictError
-} from "./integration-2sqw2jjm.js";
+  ListInput5,
+  Service44,
+  node46
+} from "./command-ha4v9y42.js";
 import {
-  SessionMessageTable
-} from "./integration-q606pcse.js";
+  Service47,
+  node49
+} from "./command-8f30jcen.js";
 import {
-  exports_environment
-} from "./integration-zn935gjz.js";
+  Service28,
+  node32
+} from "./command-1hzpknhe.js";
 import {
-  ID,
-  Info,
-  SessionSchema
-} from "./integration-bjwj8hwv.js";
+  llmClient2
+} from "./command-0e0xafbb.js";
 import {
-  exports_app
-} from "./integration-hs51b0fc.js";
+  Service27,
+  node31
+} from "./command-d674kx35.js";
 import {
-  SessionEvent
-} from "./integration-a83yvq99.js";
+  generate3
+} from "./command-7nbw4m6q.js";
 import {
-  exports_project
-} from "./integration-a7rjzrqs.js";
+  execute2
+} from "./command-bc8zabkg.js";
 import {
-  RelativePath
-} from "./integration-j07kk359.js";
+  DestinationNotFoundError2,
+  DestinationNotDirectoryError2,
+  DestinationUnavailableError2,
+  Service20,
+  node23
+} from "./command-hb55mknr.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  Service39,
+  node41
+} from "./command-8npyp30c.js";
 import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
+  make11
+} from "./command-8asq1gjq.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/session.ts
-var exports_session2 = {};
-__export(exports_session2, {
-  AttachmentError: () => AttachmentError,
-  BusyError: () => BusyError,
-  CompactionConflictError: () => CompactionConflictError,
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  ID: () => ID,
-  InboxConflictError: () => InboxConflictError,
-  Info: () => Info,
-  ListAnchor: () => ListAnchor,
-  ListInput: () => ListInput,
-  MessageDecodeError: () => MessageDecodeError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  NotFoundError: () => NotFoundError,
-  PromptConflictError: () => PromptConflictError,
-  Service: () => Service,
-  Session: () => exports_session2,
-  SessionSchema: () => SessionSchema,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SyntheticConflictError: () => SyntheticConflictError,
-  node: () => node
+var exports_session = {};
+__export(exports_session, {
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  ID: () => ID7,
+  InboxConflictError: () => InboxConflictError2,
+  Info: () => Info9,
+  ListAnchor: () => ListAnchor2,
+  ListInput: () => ListInput3,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError6,
+  PromptConflictError: () => PromptConflictError2,
+  Service: () => Service19,
+  Session: () => exports_session,
+  SessionSchema: () => SessionSchema2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  node: () => node22
 });
 import { Effect, Layer, Schema, Context, Stream } from "effect";
 import { LLMClient } from "@opencode-ai/ai";
-import { ListAnchor } from "@opencode-ai/schema/session";
+import { ListAnchor as ListAnchor2 } from "@opencode-ai/schema/session";
 import { and, desc, eq } from "drizzle-orm";
 import { Model } from "@opencode-ai/schema/model";
 import path from "path";
 import { Node } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var ListInput = exports_store.ListInput;
-class Service extends Context.Service()("@opencode/Session") {
+var ListInput3 = ListInput5;
+class Service19 extends Context.Service()("@opencode/Session") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const app = yield* exports_app.Metadata;
-  const database = yield* exports_database.Service;
+var layer = Layer.effect(Service19, Effect.gen(function* () {
+  const app = yield* Metadata2;
+  const database = yield* Service80;
   const db = database.db;
-  const bus = yield* exports_bus.Service;
-  const projects = yield* exports_project.Service;
-  const execution = yield* exports_execution.Service;
+  const bus = yield* Service79;
+  const projects = yield* Service69;
+  const execution = yield* Service28;
   const llm = yield* LLMClient.Service;
-  const transport = yield* exports_model_transport.Service;
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const moves = yield* exports_move.Service;
-  const jobs = yield* exports_job.Service;
-  const environments = yield* exports_environment.Service;
-  const sessions = yield* exports_session.make();
-  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
-  const result = Service.of({
+  const transport = yield* Service27;
+  const store = yield* Service44;
+  const instances = yield* Service33;
+  const moves = yield* Service20;
+  const jobs = yield* Service47;
+  const environments = yield* Service39;
+  const sessions = yield* make11();
+  const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
+  const result = Service19.of({
     create: Effect.fn("Session.create")(function* (input) {
-      const sessionID = input.id ?? SessionSchema.ID.create();
+      const sessionID = input.id ?? SessionSchema2.ID.create();
       const recorded = yield* store.get(sessionID);
       if (recorded)
         return recorded;
       const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
       if (input.parentID && parent === undefined)
-        return yield* new NotFoundError({ sessionID: input.parentID });
+        return yield* new NotFoundError6({ sessionID: input.parentID });
       const location = parent?.location ?? input.location;
       if (location === undefined)
         return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
       const project = yield* projects.resolve(location.directory);
-      const projected = yield* bus.publish(SessionEvent.Created, {
+      const projected = yield* bus.publish(SessionEvent2.Created, {
         sessionID,
-        slug: Slug.create(),
+        slug: Slug2.create(),
         version: app.version,
         projectID: project.id,
         parentID: input.parentID,
         location,
-        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        subpath: RelativePath2.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
         title: input.title,
         agent: input.agent,
         metadata: input.metadata ?? parent?.metadata,
@@ -180,7 +194,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           variant: input.model.variant
         } : undefined
       }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
-        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
+        if (!(defect instanceof SessionAlreadyProjected2)) {
           return Effect.die(defect);
         }
         return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
@@ -191,20 +205,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     fork: Effect.fn("Session.fork")(function* (input) {
       const parent = yield* result.get(input.sessionID);
-      const boundary = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+      const boundary = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable2.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
       if (!boundary && input.boundary.type === "before")
-        return yield* new MessageNotFoundError({
+        return yield* new MessageNotFoundError2({
           sessionID: input.sessionID,
           messageID: input.boundary.messageID
         });
       if (!boundary)
-        return yield* new ForkEmptyError({ sessionID: input.sessionID });
-      const sessionID = SessionSchema.ID.create();
+        return yield* new ForkEmptyError2({ sessionID: input.sessionID });
+      const sessionID = SessionSchema2.ID.create();
       const inherited = yield* db.transaction(() => Effect.all({
-        instructions: exports_instruction_state.current(db, parent.id),
-        instructionEntries: exports_instruction_entry.snapshot(db, parent.id)
+        instructions: current2(db, parent.id),
+        instructionEntries: snapshot2(db, parent.id)
       })).pipe(Effect.orDie);
-      yield* bus.publish(SessionEvent.Forked, {
+      yield* bus.publish(SessionEvent2.Forked, {
         sessionID,
         parentID: parent.id,
         boundary: { ...input.boundary, messageID: boundary.id },
@@ -228,7 +242,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const children = yield* result.list({ parentID: sessionID });
       yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
       yield* environments.clear(sessionID);
-      yield* bus.publish(SessionEvent.Deleted, { sessionID });
+      yield* bus.publish(SessionEvent2.Deleted, { sessionID });
       yield* bus.remove(sessionID);
     }),
     list: Effect.fn("Session.list")(function* (input) {
@@ -248,15 +262,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
     steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
     queueInbox: (input) => sessions.forSession(input.sessionID).queueInbox(input.inboxID),
-    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => exports_bus.isSynced(item) || isDurableSessionEvent(item))),
+    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => isSynced2(item) || isDurableSessionEvent(item))),
     prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
     generate: Effect.fn("Session.generate")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_generate.generate({ session, prompt: input.prompt }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(LLMClient.Service, llm));
+      return yield* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service33, instances), Effect.provideService(Service80, database), Effect.provideService(LLMClient.Service, llm));
     }),
     command: Effect.fn("Session.command")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_command.execute({ ...input, session }).pipe(Effect.provideService(exports_service.Service, instances));
+      return yield* execute2({ ...input, session }).pipe(Effect.provideService(Service33, instances));
     }),
     shell: (input) => sessions.forSession(input.sessionID).shell(input),
     skill: (input) => sessions.forSession(input.sessionID).skill(input),
@@ -296,26 +310,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return result;
 }));
-var node = Node.makeGlobalNode({
-  service: Service,
+var node22 = Node.makeGlobalNode({
+  service: Service19,
   layer,
   deps: [
-    exports_job.node,
-    exports_environment.node,
-    exports_database.node,
-    exports_bus.node,
-    exports_project.node,
-    exports_execution.node,
-    exports_model_transport.node,
-    llmClient,
-    exports_store.node,
-    exports_service.node,
-    exports_inbox.node,
-    exports_move.node,
-    exports_projector.node,
+    node49,
+    node41,
+    node84,
+    node83,
+    node72,
+    node32,
+    node31,
+    llmClient2,
+    node46,
+    node35,
+    node34,
+    node23,
+    node24,
     FSUtil.node,
-    exports_app.node
+    node81
   ]
 });
 
-export { ListAnchor, ListInput, Service, node, exports_session2 as exports_session };
+export { ListAnchor2, ListInput3, Service19, node22, exports_session };

package/dist/chunks/command-b9wsbatv.js

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

package/dist/chunks/command-bc8zabkg.js

@@ -0,0 +1,39 @@
+import {
+  Service65
+} from "./command-w0117ta3.js";
+import {
+  Service33
+} from "./command-y092mk2a.js";
+import {
+  awaitActivation2
+} from "./command-9sh4wc5j.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/session/command.ts
+var exports_command3 = {};
+__export(exports_command3, {
+  SessionCommand: () => exports_command3,
+  execute: () => execute2
+});
+import { Effect } from "effect";
+var execute2 = Effect.fn("SessionCommand.execute")(function* (input) {
+  const instances = yield* Service33;
+  const commands = yield* awaitActivation2.pipe(Effect.andThen(Service65), 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 { execute2, exports_command3 };

package/dist/chunks/{integration-1pnhmfsn.js → command-bp4zbqtd.js}

@@ -1,15 +1,15 @@
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  BlockedError2
+} from "./command-nkpkrkfc.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/plugin/plan.ts
 var exports_plan = {};
 __export(exports_plan, {
   PlanPlugin: () => exports_plan,
-  Plugin: () => Plugin
+  Plugin: () => Plugin15
 });
 import { Message, ToolFailure } from "@opencode-ai/ai";
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -29,7 +29,7 @@ You remain in Plan mode until the user switches agents. If the user asks you to
 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({
+var Plugin15 = define({
   id: "opencode.plan",
   effect: Effect.fn(function* (ctx) {
     const global = yield* Global.Service;
@@ -53,7 +53,7 @@ var Plugin = define({
         return Effect.void;
       if (event.tool !== "edit" && event.tool !== "write" && event.tool !== "patch")
         return Effect.void;
-      if (!(event.error.error instanceof exports_permission.BlockedError))
+      if (!(event.error.error instanceof BlockedError2))
         return Effect.void;
       event.error = new ToolFailure({
         message: `Cannot use ${event.tool} to modify files outside the Plan directory: ${directory}`
@@ -106,4 +106,4 @@ function lastReminder(messages, enterReminder) {
   }, undefined);
 }
 
-export { Plugin, exports_plan };
+export { Plugin15, exports_plan };