@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-p9690q97.js

@@ -0,0 +1,335 @@
+import {
+  ID16,
+  Info30,
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+import {
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  isSynced2,
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service75,
+  node80
+} from "./worktree-a8mtf1n7.js";
+import {
+  Service35,
+  node38
+} from "./worktree-vkez6a4k.js";
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  SessionMessageTable2
+} from "./worktree-5c4hm403.js";
+import {
+  node37
+} from "./worktree-vece14gy.js";
+import {
+  current2
+} from "./worktree-gnx4ytbv.js";
+import {
+  snapshot2
+} from "./worktree-7hhzr64w.js";
+import {
+  Slug2
+} from "./worktree-gebd4c9n.js";
+import {
+  SessionAlreadyProjected2,
+  node23
+} from "./worktree-s4cjsff2.js";
+import {
+  Metadata2,
+  node63
+} from "./worktree-xrd4famk.js";
+import {
+  NotFoundError9,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  ForkEmptyError2,
+  MessageDecodeError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  AttachmentError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2,
+  SkillNotFoundError2
+} from "./worktree-k7d0894y.js";
+import {
+  ListInput5,
+  Service72,
+  node77
+} from "./worktree-3bgy0jaw.js";
+import {
+  Service37,
+  node40
+} from "./worktree-y5h7afh3.js";
+import {
+  Service32,
+  node36
+} from "./worktree-d3p6gjbn.js";
+import {
+  llmClient2
+} from "./worktree-5t3nmthw.js";
+import {
+  Service23,
+  node28
+} from "./worktree-nqyaavw9.js";
+import {
+  generate3
+} from "./worktree-8qnjnss5.js";
+import {
+  execute2
+} from "./worktree-mj1ykd8q.js";
+import {
+  DestinationNotFoundError2,
+  DestinationNotDirectoryError2,
+  DestinationUnavailableError2,
+  Service18,
+  node22
+} from "./worktree-3qdzwhqx.js";
+import {
+  Service47,
+  node50
+} from "./worktree-52fpbh6z.js";
+import {
+  make12
+} from "./worktree-eynwqhf0.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session.ts
+var exports_session = {};
+__export(exports_session, {
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  ID: () => ID16,
+  InboxConflictError: () => InboxConflictError2,
+  Info: () => Info30,
+  ListAnchor: () => ListAnchor2,
+  ListInput: () => ListInput3,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError9,
+  PromptConflictError: () => PromptConflictError2,
+  Service: () => Service17,
+  Session: () => exports_session,
+  SessionSchema: () => SessionSchema2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  node: () => node21
+});
+import { Effect, Layer, Schema, Context, Stream } from "effect";
+import { LLMClient } from "@opencode/ai";
+import { ListAnchor as ListAnchor2 } from "@opencode/schema/session";
+import { and, desc, eq } from "drizzle-orm";
+import { Model } from "@opencode/schema/model";
+import path from "path";
+import { Node } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+var ListInput3 = ListInput5;
+class Service17 extends Context.Service()("@opencode/Session") {
+}
+var layer = Layer.effect(Service17, Effect.gen(function* () {
+  const app = yield* Metadata2;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const projects = yield* Service75;
+  const execution = yield* Service32;
+  const llm = yield* LLMClient.Service;
+  const transport = yield* Service23;
+  const store = yield* Service72;
+  const instances = yield* Service35;
+  const moves = yield* Service18;
+  const jobs = yield* Service37;
+  const environments = yield* Service47;
+  const sessions = yield* make12();
+  const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
+  const result = Service17.of({
+    create: Effect.fn("Session.create")(function* (input) {
+      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 NotFoundError9({ 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(SessionEvent2.Created, {
+        sessionID,
+        slug: Slug2.create(),
+        version: app.version,
+        projectID: project.id,
+        parentID: input.parentID,
+        location,
+        subpath: RelativePath2.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        title: input.title,
+        agent: input.agent,
+        metadata: input.metadata ?? parent?.metadata,
+        model: input.model ? {
+          id: Model.ID.make(input.model.id),
+          providerID: input.model.providerID,
+          variant: input.model.variant
+        } : undefined
+      }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
+        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)));
+      }));
+      if (projected.type === "existing")
+        return projected.session;
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    fork: Effect.fn("Session.fork")(function* (input) {
+      const parent = yield* result.get(input.sessionID);
+      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 MessageNotFoundError2({
+          sessionID: input.sessionID,
+          messageID: input.boundary.messageID
+        });
+      if (!boundary)
+        return yield* new ForkEmptyError2({ sessionID: input.sessionID });
+      const sessionID = SessionSchema2.ID.create();
+      const inherited = yield* db.transaction(() => Effect.all({
+        instructions: current2(db, parent.id),
+        instructionEntries: snapshot2(db, parent.id)
+      })).pipe(Effect.orDie);
+      yield* bus.publish(SessionEvent2.Forked, {
+        sessionID,
+        parentID: parent.id,
+        boundary: { ...input.boundary, messageID: boundary.id },
+        ...inherited
+      });
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    get: (sessionID) => sessions.forSession(sessionID).get(),
+    environment: Effect.fn("Session.environment")(function* (input) {
+      yield* result.get(input.sessionID);
+      if (input.variables !== undefined)
+        yield* environments.set(input.sessionID, input.variables);
+      return yield* environments.get(input.sessionID);
+    }),
+    view: (input) => sessions.forSession(input.sessionID).view(input),
+    remove: Effect.fn("Session.remove")(function* (sessionID) {
+      yield* result.get(sessionID);
+      yield* execution.interrupt(sessionID);
+      yield* execution.awaitIdle(sessionID);
+      yield* transport.close(sessionID);
+      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(SessionEvent2.Deleted, { sessionID });
+      yield* bus.remove(sessionID);
+    }),
+    list: Effect.fn("Session.list")(function* (input) {
+      return { data: yield* store.list(input) };
+    }),
+    messages: Effect.fn("Session.messages")(function* (input) {
+      yield* result.get(input.sessionID);
+      return yield* store.messages(input);
+    }),
+    message: (input) => sessions.forSession(input.sessionID).message(input.messageID),
+    updateMessage: (input) => sessions.forSession(input.sessionID).updateMessage(input),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
+    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) => 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* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service35, 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* execute2({ ...input, session }).pipe(Effect.provideService(Service35, instances));
+    }),
+    shell: (input) => sessions.forSession(input.sessionID).shell(input),
+    skill: (input) => sessions.forSession(input.sessionID).skill(input),
+    switchAgent: (input) => sessions.forSession(input.sessionID).switchAgent(input),
+    switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
+    rename: (input) => sessions.forSession(input.sessionID).rename(input),
+    move: moves.move,
+    compact: (input) => sessions.forSession(input.sessionID).compact(input),
+    wait: (sessionID) => sessions.forSession(sessionID).wait(),
+    active: execution.active,
+    background: Effect.fn("Session.background")(function* (sessionID) {
+      yield* result.get(sessionID);
+      const backgrounded = yield* jobs.backgroundAll({ sessionID });
+      if (backgrounded.length === 0)
+        return;
+      yield* result.synthetic({
+        sessionID,
+        text: [
+          "User requested that active blocking work be moved to the background.",
+          "",
+          "Backgrounded work:",
+          ...backgrounded.map((job) => `- ${job.type}: ${job.title && job.title.length > 0 ? job.title : job.id}`),
+          "",
+          "The backgrounded work is still unfinished. Move on to other work if you can. If there is nothing else useful to do, finish your response. Do not wait, sleep, poll, or report the backgrounded work as complete until a later completion notification is added to the conversation."
+        ].join(`
+`)
+      }).pipe(Effect.catchTag("Session.SyntheticConflictError", Effect.die));
+    }),
+    resume: (sessionID) => sessions.forSession(sessionID).resume(),
+    synthetic: (input) => sessions.forSession(input.sessionID).synthetic(input),
+    interrupt: (sessionID, options) => sessions.forSession(sessionID).interrupt(options),
+    revert: {
+      stage: (input) => sessions.forSession(input.sessionID).revert.stage(input),
+      clear: (sessionID) => sessions.forSession(sessionID).revert.clear(),
+      commit: (sessionID) => sessions.forSession(sessionID).revert.commit()
+    }
+  });
+  return result;
+}));
+var node21 = Node.makeGlobalNode({
+  service: Service17,
+  layer,
+  deps: [
+    node40,
+    node50,
+    node85,
+    node84,
+    node80,
+    node36,
+    node28,
+    llmClient2,
+    node77,
+    node38,
+    node37,
+    node22,
+    node23,
+    FSUtil.node,
+    node63
+  ]
+});
+
+export { ListAnchor2, ListInput3, Service17, node21, exports_session };

package/dist/chunks/worktree-paphc93g.js

@@ -0,0 +1,9 @@
+// src/filesystem/watcher-binding.ts
+import { createRequire } from "node:module";
+function load2() {
+  const require2 = createRequire(import.meta.url);
+  const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC;
+  return require2(process.env.OPENCODE_PARCEL_WATCHER_PATH ?? `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`);
+}
+
+export { load2 };

package/dist/chunks/worktree-pcpv7kp0.js

@@ -0,0 +1,140 @@
+import {
+  Service55,
+  node59
+} from "./worktree-ccrec4q8.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service54,
+  node58
+} from "./worktree-r82b328h.js";
+import {
+  names2,
+  discover2
+} from "./worktree-zxq2ej10.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/source.ts
+var exports_source = {};
+__export(exports_source, {
+  ConfigPluginSource: () => exports_source,
+  Service: () => Service4,
+  empty: () => empty2,
+  layer: () => layer5,
+  node: () => node7
+});
+import { FSUtil } from "@opencode/util/fs-util";
+import { Host } from "@opencode/plugin/host";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Option, PubSub, Stream } from "effect";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+class Service4 extends Context.Service()("@opencode/ConfigPluginSource") {
+}
+var layer5 = Layer.effect(Service4, Effect.gen(function* () {
+  const config = yield* Service54;
+  const watcher = yield* Service55;
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service74;
+  const configuredChanges = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (entries, operations) {
+    for (const operation of operations) {
+      if (operation.type !== "add" || !path.isAbsolute(operation.target))
+        continue;
+      if (watched.has(operation.target))
+        continue;
+      if (isPluginSource(entries, operation.target))
+        continue;
+      watched.add(operation.target);
+      const updates = yield* watcher.subscribe({
+        path: operation.target,
+        type: (yield* fs.isDir(operation.target)) ? "directory" : "file"
+      });
+      yield* updates.pipe(Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)), Effect.catchCause((cause) => Effect.logError("configured plugin watch failed", { target: operation.target, cause })), Effect.forkScoped({ startImmediately: true }));
+    }
+  });
+  return Service4.of({
+    operations: Effect.fn("ConfigPluginSource.operations")(function* () {
+      const entries = yield* config.entries();
+      const operations = yield* scan(fs, location, entries);
+      yield* watchConfiguredSources(entries, operations);
+      return operations;
+    }),
+    changes: () => Stream.merge(config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path))), Stream.map(() => {
+      return;
+    })), Stream.fromPubSub(configuredChanges))
+  });
+}));
+var node7 = makeLocationNode({
+  service: Service4,
+  layer: layer5,
+  deps: [node58, FSUtil.node, node59, node79]
+});
+var empty2 = makeLocationNode({
+  service: Service4,
+  layer: Layer.succeed(Service4, Service4.of({
+    operations: () => Effect.succeed([]),
+    changes: () => Stream.never
+  })),
+  deps: []
+});
+function parse(input) {
+  if (typeof input !== "string") {
+    return { type: "add", target: input.package, options: input.options ?? {} };
+  }
+  if (!input.startsWith("-"))
+    return { type: "add", target: input, options: {} };
+  if (input.length === 1)
+    throw new Error("Plugin remove operation requires a target");
+  return { type: "remove", target: input.slice(1) };
+}
+var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries) {
+  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => discover2(fs, entry.path).pipe(Effect.map((targets) => targets.map((target) => ({ type: "add", target, options: {} }))))).pipe(Effect.map((items) => items.flat()));
+  const configured = entries.filter((entry) => entry.type === "document").flatMap((entry) => (entry.info.plugins ?? []).map(parse).map((operation) => {
+    if (operation.type === "remove")
+      return operation;
+    const directory = entry.path ? path.dirname(entry.path) : location.directory;
+    const target = operation.target.startsWith("file://") ? fileURLToPath(operation.target) : operation.target.startsWith("./") || operation.target.startsWith("../") ? path.resolve(directory, operation.target) : operation.target;
+    return { ...operation, target };
+  }));
+  const resolved = yield* Effect.forEach(configured, (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return Option.some(operation);
+    if (yield* fs.isFile(operation.target)) {
+      yield* Effect.logWarning("configured plugin path must be a directory", { target: operation.target });
+      return Option.none();
+    }
+    return Option.some(operation);
+  })).pipe(Effect.map((operations) => operations.flatMap(Option.toArray)));
+  return yield* Effect.forEach([...discovered, ...resolved], (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return [operation];
+    if (!(yield* fs.existsSafe(operation.target)))
+      return [operation];
+    const directory = yield* fs.isDir(operation.target);
+    const entrypoints = directory ? yield* Effect.sync(() => Host.resolve({ directory: operation.target })) : { server: pathToFileURL(operation.target).href };
+    if (!entrypoints.server)
+      return [];
+    if (directory) {
+      const root = yield* fs.resolve(operation.target);
+      const server = yield* fs.resolve(fileURLToPath(entrypoints.server));
+      if (!FSUtil.contains(root, server))
+        return [];
+    }
+    const times = yield* Effect.forEach([
+      ...Object.values(entrypoints).filter((entry) => entry !== undefined).map((entry) => fileURLToPath(entry)),
+      path.join(directory ? operation.target : path.dirname(operation.target), "package.json")
+    ], (entry) => fs.stat(entry).pipe(Effect.map((info) => Option.getOrElse(info.mtime, () => new Date(0)).getTime()), Effect.orElseSucceed(() => 0)));
+    return [{ ...operation, mtime: Math.max(...times) }];
+  })).pipe(Effect.map((operations) => operations.flat()));
+});
+function isPluginSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && names2.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+}
+
+export { Service4, layer5, node7, empty2, exports_source };

package/dist/chunks/worktree-pjmw00w1.js

@@ -0,0 +1,31 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/project/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  Current: () => Current3,
+  Event: () => Event19,
+  ID: () => ID18,
+  Info: () => Info33,
+  ProjectSchema: () => exports_schema,
+  UpdateInput: () => UpdateInput4,
+  Vcs: () => Vcs3
+});
+import { Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+var ID18 = Project.ID;
+var Current3 = Project.Current;
+var Info33 = Project.Info;
+var UpdateInput4 = Project.UpdateInput;
+var Event19 = Project.Event;
+var Vcs3 = Schema.Struct({
+  type: Project.Vcs,
+  store: AbsolutePath2
+});
+
+export { ID18, Current3, Info33, UpdateInput4, Event19, Vcs3, exports_schema };