@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-8v2yzmx6.js

@@ -0,0 +1,294 @@
+import {
+  exports_message
+} from "./ripgrep-25pxtba7.js";
+import {
+  SessionInboxTable,
+  SessionMessageTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+import {
+  exports_schema
+} from "./ripgrep-y8rs54ne.js";
+import {
+  exports_keyed_mutex
+} from "./ripgrep-0kvmztkf.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  steer: () => steer,
+  serialized: () => serialized,
+  queue: () => queue,
+  promote: () => promote,
+  projectDeliveryChanged: () => projectDeliveryChanged,
+  projectDelivered: () => projectDelivered,
+  projectCancelled: () => projectCancelled,
+  projectAdmitted: () => projectAdmitted,
+  nextSteer: () => nextSteer,
+  nextQueued: () => nextQueued,
+  nextPromotable: () => nextPromotable,
+  moveIDs: () => moveIDs,
+  list: () => list,
+  has: () => has,
+  find: () => find,
+  equivalent: () => equivalent,
+  cancel: () => cancel,
+  admitCompaction: () => admitCompaction,
+  admit: () => admit,
+  UserPayload: () => UserPayload,
+  User: () => User,
+  SyntheticPayload: () => SyntheticPayload,
+  Synthetic: () => Synthetic,
+  SessionInbox: () => exports_inbox,
+  MovePayload: () => MovePayload,
+  Move: () => Move,
+  LifecycleConflict: () => LifecycleConflict,
+  Item: () => Item,
+  Info: () => Info,
+  Delivery: () => Delivery,
+  CompactionPayload: () => CompactionPayload,
+  Compaction: () => Compaction
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { DateTime, Effect, Schema } from "effect";
+import {
+  Compaction,
+  CompactionPayload,
+  Delivery,
+  Info,
+  Item,
+  Move,
+  MovePayload,
+  Synthetic,
+  SyntheticPayload,
+  User,
+  UserPayload
+} from "@opencode-ai/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload);
+var encodeUser = Schema.encodeSync(UserPayload);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload);
+var encodeCompaction = Schema.encodeSync(CompactionPayload);
+var decodeMove = Schema.decodeUnknownSync(MovePayload);
+var encodeMove = Schema.encodeSync(MovePayload);
+var decodeMessage = Schema.decodeUnknownSync(exports_message.Info);
+var inboxLocks = exports_keyed_mutex.makeUnsafe();
+var serialized = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict extends Schema.TaggedErrorClass()("SessionInbox.LifecycleConflict", {
+  id: exports_message.ID
+}) {
+}
+var fromRow = (row) => {
+  const base = {
+    id: exports_message.ID.make(row.id),
+    sessionID: exports_schema.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict({ id: base.id });
+};
+var find = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
+  const row = yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* Effect.die(new LifecycleConflict({ id }));
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
+  const base = { id, sessionID, timeCreated: message.time.created, delivery };
+  if (message.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* Effect.die(new LifecycleConflict({ id }));
+});
+var admit = Effect.fn("SessionInbox.admit")(function* (db, bus, request) {
+  const existing = yield* find(db, request.id);
+  if (existing !== undefined) {
+    if (existing.type === "compaction")
+      return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+    return existing;
+  }
+  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.item.delivery);
+  if (promoted !== undefined)
+    return promoted;
+  return yield* bus.publish(SessionEvent.InboxEnqueued, {
+    inboxID: request.id,
+    sessionID: request.sessionID,
+    item: request.item
+  }).pipe(Effect.flatMap((event) => {
+    const base = {
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created)
+    };
+    return Effect.succeed(Info.make({ ...base, ...request.item }));
+  }), Effect.catchDefect((defect) => find(db, request.id).pipe(Effect.flatMap((stored) => stored?.type === request.item.type ? Effect.succeed(stored) : Effect.die(defect)))));
+});
+var admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (db, bus, input) {
+  const admitted = yield* admit(db, bus, {
+    id: input.id,
+    sessionID: input.sessionID,
+    item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery })
+  });
+  if (admitted.type === "compaction")
+    return admitted;
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(eq(SessionMessageTable.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.item.type,
+    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
+    delivery: request.item.delivery,
+    enqueued_seq: request.enqueuedSeq,
+    time_created: request.timeCreated
+  }).onConflictDoNothing().returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+});
+var projectDelivered = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), or(eq(SessionInboxTable.delivery, "queue"), eq(SessionInboxTable.delivery, "steer")))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable).set({ delivery: input.to }).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), eq(SessionInboxTable.delivery, input.from))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectDeliveryChanged = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.session_id, sessionID)).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable.id }).from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.type, "move"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextQueued = Effect.fn("SessionInbox.nextQueued")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return row ? fromRow(row) : undefined;
+});
+var nextSteer = Effect.fn("SessionInbox.nextSteer")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return row ? fromRow(row) : undefined;
+});
+var nextPromotable = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  return (yield* nextSteer(db, sessionID)) ?? (promotable === "input" ? yield* nextQueued(db, sessionID) : undefined);
+});
+var has = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable.id }).from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), scope === "any" ? undefined : scope === "input" ? or(eq(SessionInboxTable.delivery, "steer"), eq(SessionInboxTable.delivery, "queue")) : eq(SessionInboxTable.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var equivalent = (input, expected) => {
+  if (input.type !== expected.item.type || input.delivery !== expected.item.delivery || input.sessionID !== expected.sessionID)
+    return false;
+  if (input.type === "user" && expected.item.type === "user")
+    return JSON.stringify(encodeUser(input.payload)) === JSON.stringify(encodeUser(expected.item.payload));
+  if (input.type === "synthetic" && expected.item.type === "synthetic")
+    return JSON.stringify(encodeSynthetic(input.payload)) === JSON.stringify(encodeSynthetic(expected.item.payload));
+  if (input.type === "compaction" && expected.item.type === "compaction")
+    return true;
+  if (input.type === "move" && expected.item.type === "move")
+    return JSON.stringify(encodeMove(input.payload)) === JSON.stringify(encodeMove(expected.item.payload));
+  return false;
+};
+var publishMutation = (input, effect) => serialized(input.sessionID, effect).pipe(Effect.asVoid);
+var cancel = Effect.fn("SessionInbox.cancel")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxCancelled, {
+  sessionID: input.sessionID,
+  inboxID: input.id
+})));
+var steer = Effect.fn("SessionInbox.steer")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "steer"
+})));
+var queue = Effect.fn("SessionInbox.queue")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "queue"
+})));
+var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
+  yield* Effect.forEach(rows, (row) => {
+    const entry = fromRow(row);
+    if (entry.type === "compaction")
+      return Effect.die(new LifecycleConflict({ id: entry.id }));
+    return bus.publish(SessionEvent.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect))) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized(sessionID, Effect.gen(function* () {
+    const steers = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    if (steers.length > 0 || scope === "steer") {
+      const control2 = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      return yield* publish(db, bus, sessionID, control2 === -1 ? steers : steers.slice(0, control2));
+    }
+    const queued = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
+    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
+  }));
+});
+
+export { Compaction, CompactionPayload, Delivery, Info, Item, Move, MovePayload, Synthetic, SyntheticPayload, User, UserPayload, serialized, LifecycleConflict, find, admit, admitCompaction, projectAdmitted, projectDelivered, projectCancelled, projectDeliveryChanged, list, moveIDs, nextQueued, nextSteer, nextPromotable, has, equivalent, cancel, steer, queue, promote, exports_inbox };

package/dist/chunks/ripgrep-8v47shgf.js

@@ -0,0 +1,33 @@
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/project/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  Vcs: () => Vcs,
+  ProjectSchema: () => exports_schema,
+  Info: () => Info,
+  ID: () => ID,
+  Current: () => Current
+});
+import { Schema } from "effect";
+import { Project } from "@opencode-ai/schema/project";
+var ID = Project.ID;
+var Current = Project.Current;
+var Info = Project.Info;
+var Vcs = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("git"),
+    store: AbsolutePath
+  }),
+  Schema.Struct({
+    type: Schema.Literal("hg"),
+    store: AbsolutePath
+  })
+]);
+
+export { ID, Current, Info, Vcs, exports_schema };

package/dist/chunks/ripgrep-8vhzxx5g.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  canonical: () => canonical,
+  WorktreeDirectory: () => exports_directory,
+  DirectoryUnavailableError: () => DirectoryUnavailableError
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError extends Schema.TaggedErrorClass()("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/ripgrep-8w9tzfz1.js

@@ -0,0 +1,14 @@
+// src/util/lazy.ts
+function lazy(fn) {
+  let value;
+  let loaded = false;
+  return () => {
+    if (loaded)
+      return value;
+    loaded = true;
+    value = fn();
+    return value;
+  };
+}
+
+export { lazy };

package/dist/chunks/ripgrep-8ywqk2j9.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  tokens: () => tokens,
+  record: () => record,
+  calculateCost: () => calculateCost,
+  add: () => add,
+  SessionUsage: () => exports_usage
+});
+import { Money } from "@opencode-ai/schema/money";
+var safe = (value) => Math.max(0, Number.isFinite(value) ? value ?? 0 : 0);
+var tokens = (usage) => ({
+  input: safe(usage?.nonCachedInputTokens),
+  output: safe(usage?.visibleOutputTokens),
+  reasoning: safe(usage?.reasoningTokens),
+  cache: {
+    read: safe(usage?.cacheReadInputTokens),
+    write: safe(usage?.cacheWriteInputTokens)
+  }
+});
+function calculateCost(costs, usage) {
+  const context = usage.input + usage.cache.read + usage.cache.write;
+  const tier = costs.filter((cost2) => cost2.tier?.type === "context" && context > cost2.tier.size).toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0];
+  const cost = tier ?? costs.find((cost2) => cost2.tier === undefined);
+  if (!cost)
+    return Money.USD.zero;
+  return Money.USD.make((usage.input * cost.input + (usage.output + usage.reasoning) * cost.output + usage.cache.read * cost.cache.read + usage.cache.write * cost.cache.write) / 1e6);
+}
+var record = (usage, costs) => {
+  const normalized = tokens(usage);
+  return { tokens: normalized, cost: calculateCost(costs, normalized) };
+};
+var add = (a, b) => ({
+  cost: Money.USD.make(a.cost + b.cost),
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: {
+      read: a.tokens.cache.read + b.tokens.cache.read,
+      write: a.tokens.cache.write + b.tokens.cache.write
+    }
+  }
+});
+
+export { tokens, calculateCost, record, add, exports_usage };

package/dist/chunks/ripgrep-906y0b6d.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260601202201_amazing_prowler.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601202201_amazing_prowler",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`permission\`;`);
+    });
+  }
+};
+var _20260601202201_amazing_prowler_default = migration;
+
+export { _20260601202201_amazing_prowler_default };