@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-cf4snx6d.js

@@ -0,0 +1,107 @@
+// src/database/drizzle/sqlite-core/effect/query.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import {
+  makeDefaultRqbMapper
+} from "drizzle-orm/relations";
+import { sql } from "drizzle-orm/sql/sql";
+
+class SQLiteEffectRelationalQueryBuilder2 {
+  schema;
+  table;
+  tableConfig;
+  dialect;
+  session;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryBuilderV2";
+  constructor(schema, table, tableConfig, dialect, session, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+  }
+  findMany(config) {
+    return new SQLiteEffectRelationalQuery2(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "many", this.rowMode, this.forbidJsonb);
+  }
+  findFirst(config) {
+    return new SQLiteEffectRelationalQuery2(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "first", this.rowMode, this.forbidJsonb);
+  }
+}
+
+class SQLiteEffectRelationalQuery2 {
+  schema;
+  tableConfig;
+  dialect;
+  session;
+  config;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryV2";
+  mode;
+  table;
+  constructor(schema, table, tableConfig, dialect, session, config, mode, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _prepare(isOneTimeQuery = true) {
+    const { query, builtQuery } = this._toSQL();
+    const mapperConfig = {
+      isFirst: this.mode === "first",
+      parseJson: !this.rowMode,
+      parseJsonIfString: false,
+      rootJsonMappers: true,
+      selection: query.selection
+    };
+    return this.session[isOneTimeQuery ? "prepareOneTimeRelationalQuery" : "prepareRelationalQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", makeDefaultRqbMapper(mapperConfig), mapperConfig);
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    const query = this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      isNested: this.rowMode,
+      jsonb
+    });
+    if (this.rowMode) {
+      const jsonColumns = sql.join(query.selection.map((s) => {
+        return sql`${sql.raw(this.dialect.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
+      }), sql`, `);
+      query.sql = sql`select json_object(${jsonColumns}) as ${sql.identifier("r")} from (${query.sql}) as ${sql.identifier("t")}`;
+    }
+    return query;
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  execute(placeholderValues) {
+    return this.mode === "first" ? this._prepare().get(placeholderValues) : this._prepare().all(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectRelationalQuery2);
+
+export { SQLiteEffectRelationalQueryBuilder2, SQLiteEffectRelationalQuery2 };

package/dist/chunks/aisdk-native-cfpkc3c9.js

@@ -0,0 +1,17 @@
+import {
+  absoluteColumn2
+} from "./aisdk-native-6msgmcgs.js";
+import {
+  ProjectTable2
+} from "./aisdk-native-8p4f9s12.js";
+
+// src/worktree/sql.ts
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorktreeTable2 = sqliteTable("worktree", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+
+export { WorktreeTable2 };

package/dist/chunks/aisdk-native-ch22x6z2.js

@@ -0,0 +1,137 @@
+import {
+  SQLiteEffectCountBuilder2
+} from "./aisdk-native-f0mxakyp.js";
+import {
+  SQLiteEffectDeleteBase2
+} from "./aisdk-native-w3wsvvr9.js";
+import {
+  SQLiteEffectInsertBuilder2
+} from "./aisdk-native-7bmhse3q.js";
+import {
+  SQLiteEffectRelationalQueryBuilder2
+} from "./aisdk-native-cf4snx6d.js";
+import {
+  SQLiteEffectRaw2
+} from "./aisdk-native-822emrt2.js";
+import {
+  SQLiteEffectSelectBuilder2
+} from "./aisdk-native-wd87259q.js";
+import {
+  SQLiteEffectUpdateBuilder2
+} from "./aisdk-native-m9w0rfyh.js";
+
+// src/database/drizzle/sqlite-core/effect/db.ts
+import { Effect } from "effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { sql } from "drizzle-orm/sql/sql";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+import { WithSubquery } from "drizzle-orm/subquery";
+class SQLiteEffectDatabase2 {
+  dialect;
+  session;
+  rowModeRQB;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectDatabase";
+  query;
+  constructor(dialect, session, relations, rowModeRQB, forbidJsonb) {
+    this.dialect = dialect;
+    this.session = session;
+    this.rowModeRQB = rowModeRQB;
+    this.forbidJsonb = forbidJsonb;
+    this._ = {
+      relations,
+      session
+    };
+    this.query = {};
+    for (const [tableName, relation] of Object.entries(relations)) {
+      this.query[tableName] = new SQLiteEffectRelationalQueryBuilder2(relations, relations[relation.name].table, relation, dialect, session, rowModeRQB, forbidJsonb);
+    }
+    this.$cache = {
+      invalidate: (_params) => Effect.void
+    };
+  }
+  $with = (alias, selection) => {
+    const self = this;
+    const as = (qb) => {
+      if (typeof qb === "function") {
+        qb = qb(new QueryBuilder(self.dialect));
+      }
+      return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
+    };
+    return { as };
+  };
+  $cache;
+  $count(source, filters) {
+    return new SQLiteEffectCountBuilder2({ source, filters, session: this.session });
+  }
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new SQLiteEffectSelectBuilder2({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new SQLiteEffectSelectBuilder2({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      });
+    }
+    function update(table) {
+      return new SQLiteEffectUpdateBuilder2(table, self.session, self.dialect, queries);
+    }
+    function insert(into) {
+      return new SQLiteEffectInsertBuilder2(into, self.session, self.dialect, queries);
+    }
+    function delete_(from) {
+      return new SQLiteEffectDeleteBase2(from, self.session, self.dialect, queries);
+    }
+    return { select, selectDistinct, update, insert, delete: delete_ };
+  }
+  select(fields) {
+    return new SQLiteEffectSelectBuilder2({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
+  }
+  selectDistinct(fields) {
+    return new SQLiteEffectSelectBuilder2({
+      fields: fields ?? undefined,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    });
+  }
+  update(table) {
+    return new SQLiteEffectUpdateBuilder2(table, this.session, this.dialect);
+  }
+  insert(into) {
+    return new SQLiteEffectInsertBuilder2(into, this.session, this.dialect);
+  }
+  delete(from) {
+    return new SQLiteEffectDeleteBase2(from, this.session, this.dialect);
+  }
+  raw(query, action, execute) {
+    const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+    return new SQLiteEffectRaw2(() => execute(sequel), () => sequel, action, this.dialect, (result) => result);
+  }
+  run(query) {
+    return this.raw(query, "run", (sequel) => this.session.run(sequel));
+  }
+  all(query) {
+    return this.raw(query, "all", (sequel) => this.session.all(sequel));
+  }
+  get(query) {
+    return this.raw(query, "get", (sequel) => this.session.get(sequel));
+  }
+  values(query) {
+    return this.raw(query, "values", (sequel) => this.session.values(sequel));
+  }
+  transaction = (tx, config) => this.session.transaction(tx, config);
+}
+
+export { SQLiteEffectDatabase2 };

package/dist/chunks/aisdk-native-cjg4xdhd.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  App: () => exports_app,
+  Metadata: () => Metadata2,
+  configured: () => configured8,
+  layer: () => layer21,
+  make: () => make19,
+  node: () => node56,
+  useragent: () => useragent2
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var Metadata2 = Context.Reference("@opencode/App", {
+  defaultValue: () => make19()
+});
+function make19(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent2(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer21 = (input) => Layer.succeed(Metadata2, make19(input));
+var configured8 = (input) => makeGlobalNode({ service: Metadata2, layer: layer21(input), deps: [] });
+var node56 = configured8();
+
+export { Metadata2, make19, useragent2, layer21, configured8, node56, exports_app };

package/dist/chunks/aisdk-native-cq37gk0t.js

@@ -0,0 +1,173 @@
+import {
+  Hash2,
+  read3,
+  diff2,
+  renderInitial2,
+  renderUpdate2,
+  applyHashDelta2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  InstructionBlobTable2,
+  InstructionStateTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/instruction-state.ts
+var exports_instruction_state = {};
+__export(exports_instruction_state, {
+  InstructionState: () => exports_instruction_state,
+  advanceEpoch: () => advanceEpoch2,
+  apply: () => apply2,
+  commit: () => commit3,
+  current: () => current2,
+  initial: () => initial2,
+  initialize: () => initialize3,
+  observe: () => observe3,
+  prepare: () => prepare4,
+  preview: () => preview3,
+  reset: () => reset2
+});
+import { eq, inArray, sql } from "drizzle-orm";
+import { Effect, Option } from "effect";
+var observe3 = Effect.fn("InstructionState.observe")(function* (db, instructions, sessionID) {
+  const [observed, stored] = yield* Effect.all([read3(instructions), find(db, sessionID)], {
+    concurrency: "unbounded"
+  });
+  const result = yield* observeAgainst(observed, stored?.current_values);
+  return {
+    sessionID,
+    initial: !stored,
+    previous: stored?.current_values ?? {},
+    ...result
+  };
+});
+var commit3 = Effect.fn("InstructionState.commit")(function* (db, bus, instructions, observation) {
+  if (!observation.initial && Object.keys(observation.delta).length === 0)
+    return;
+  const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation);
+  yield* bus.publish(SessionEvent2.InstructionsUpdated, {
+    sessionID: observation.sessionID,
+    delta: observation.delta,
+    ...text.length > 0 ? { text } : {}
+  }, {
+    ...observation.initial ? { metadata: { instructions: { initial: true } } } : {},
+    commit: () => insertBlobs(db, observation.blobs)
+  });
+});
+var renderUpdateText = Effect.fnUntraced(function* (db, instructions, observation) {
+  const replaced = Object.entries(observation.previous).filter(([key]) => Object.hasOwn(observation.delta, key));
+  const blobs = yield* loadBlobs(db, replaced.map(([, hash]) => hash));
+  const previous = Object.fromEntries(replaced.map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+  const admitted = new Map(Object.entries(observation.blobs).map(([hash, value]) => [Hash2.make(hash), value]));
+  return renderUpdate2(instructions, previous, dereferenceDelta(observation.delta, admitted));
+});
+var prepare4 = Effect.fn("InstructionState.prepare")(function* (db, bus, instructions, sessionID) {
+  yield* commit3(db, bus, instructions, yield* observe3(db, instructions, sessionID));
+});
+var apply2 = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, delta) {
+  const stored = yield* find(db, sessionID);
+  const current = applyHashDelta2(stored?.current_values ?? {}, delta);
+  if (!stored) {
+    yield* db.insert(InstructionStateTable2).values({
+      session_id: sessionID,
+      epoch_start: seq,
+      through_seq: seq,
+      initial_values: current,
+      current_values: current
+    }).run().pipe(Effect.orDie);
+    return;
+  }
+  yield* db.update(InstructionStateTable2).set({ through_seq: seq, current_values: current }).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initialize3 = Effect.fn("InstructionState.initialize")(function* (db, sessionID, seq, values) {
+  yield* db.insert(InstructionStateTable2).values({
+    session_id: sessionID,
+    epoch_start: seq,
+    through_seq: seq,
+    initial_values: values,
+    current_values: values
+  }).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var advanceEpoch2 = Effect.fn("InstructionState.advanceEpoch")(function* (db, sessionID, epochStart) {
+  yield* db.update(InstructionStateTable2).set({
+    epoch_start: epochStart,
+    through_seq: epochStart,
+    initial_values: sql`${InstructionStateTable2.current_values}`
+  }).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var reset2 = Effect.fn("InstructionState.reset")(function* (db, sessionID) {
+  yield* db.delete(InstructionStateTable2).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initial2 = Effect.fn("InstructionState.initial")(function* (db, sessionID, instructions) {
+  const state = yield* find(db, sessionID);
+  if (!state)
+    return yield* Effect.die(new Error(`Instruction state not found during assembly: ${sessionID}`));
+  const blobs = yield* loadBlobs(db, Object.values(state.initial_values));
+  return renderInitial2(instructions, dereference(state.initial_values, blobs));
+});
+var current2 = Effect.fn("InstructionState.current")(function* (db, sessionID) {
+  return (yield* find(db, sessionID))?.current_values;
+});
+var preview3 = Effect.fn("InstructionState.preview")(function* (db, sessionID, instructions, observed) {
+  const state = yield* find(db, sessionID);
+  const result = yield* observeAgainst(observed, state?.current_values);
+  const observedBlobs = new Map(Object.entries(result.blobs).map(([hash, value]) => [Hash2.make(hash), value]));
+  if (!state) {
+    const values = dereference(result.current, observedBlobs);
+    return { initial: renderInitial2(instructions, values), update: "" };
+  }
+  const stored = yield* loadBlobs(db, [...Object.values(state.initial_values), ...Object.values(state.current_values)]);
+  return {
+    initial: renderInitial2(instructions, dereference(state.initial_values, stored)),
+    update: renderUpdate2(instructions, dereference(state.current_values, stored), dereferenceDelta(result.delta, observedBlobs))
+  };
+});
+var observeAgainst = Effect.fnUntraced(function* (observed, previous) {
+  const admission = yield* diff2(observed, previous);
+  return {
+    current: applyHashDelta2(previous ?? {}, admission.delta),
+    ...admission
+  };
+});
+var find = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select().from(InstructionStateTable2).where(eq(InstructionStateTable2.session_id, sessionID)).get().pipe(Effect.orDie);
+});
+var insertBlobs = Effect.fnUntraced(function* (db, blobs) {
+  const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: Hash2.make(hash), value }));
+  if (rows.length === 0)
+    return;
+  yield* db.insert(InstructionBlobTable2).values(rows).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var loadBlobs = Effect.fnUntraced(function* (db, values) {
+  const hashes = [...new Set(values)];
+  const batches = Array.from({ length: Math.ceil(hashes.length / 500) }, (_, index) => hashes.slice(index * 500, (index + 1) * 500));
+  const rows = (yield* Effect.forEach(batches, (batch) => db.select().from(InstructionBlobTable2).where(inArray(InstructionBlobTable2.hash, batch)).all().pipe(Effect.orDie), { concurrency: 4 })).flat();
+  const blobs = new Map(rows.map((row) => [row.hash, row.value]));
+  for (const hash of hashes) {
+    if (!blobs.has(hash))
+      return yield* Effect.die(new Error(`Instruction blob not found: ${hash}`));
+  }
+  return blobs;
+});
+function dereference(values, blobs) {
+  return Object.fromEntries(Object.entries(values).map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+}
+function dereferenceDelta(delta, blobs) {
+  return Object.fromEntries(Object.entries(delta).map(([key, hash]) => [
+    key,
+    hash === "removed" ? Option.none() : Option.some(requireBlob(blobs, hash))
+  ]));
+}
+function requireBlob(blobs, hash) {
+  const value = blobs.get(hash);
+  if (value === undefined)
+    throw new Error(`Instruction blob not found: ${hash}`);
+  return value;
+}
+
+export { observe3, commit3, prepare4, apply2, initialize3, advanceEpoch2, reset2, initial2, current2, preview3, exports_instruction_state };