@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-88jbfw8z.js

@@ -0,0 +1,41 @@
+import {
+  absoluteArrayColumn,
+  absoluteColumn
+} from "./ripgrep-zbqqnp0n.js";
+import {
+  Timestamps
+} from "./ripgrep-sem2g21k.js";
+
+// src/project/sql.ts
+import { isNotNull, isNull, ne, or } from "drizzle-orm";
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var ProjectTable = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: absoluteColumn().notNull(),
+  vcs: text().$type(),
+  name: text(),
+  icon_url: text(),
+  icon_url_override: text(),
+  icon_color: text(),
+  ...Timestamps,
+  time_initialized: integer(),
+  sandboxes: absoluteArrayColumn().notNull(),
+  commands: text({ mode: "json" }).$type()
+});
+var ProjectDirectoryTable = sqliteTable("project_directory", {
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  directory: absoluteColumn().notNull(),
+  type: text().$type(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+function upsertProject(db, project) {
+  const vcs = project.vcs?.type;
+  return db.insert(ProjectTable).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
+    target: ProjectTable.id,
+    set: { worktree: project.canonical, vcs: vcs ?? null },
+    setWhere: or(ne(ProjectTable.worktree, project.canonical), vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs))
+  }).run();
+}
+
+export { ProjectTable, ProjectDirectoryTable, upsertProject };

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

@@ -0,0 +1,196 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/instructions/index.ts
+var exports_instructions = {};
+__export(exports_instructions, {
+  unavailable: () => unavailable,
+  renderUpdate: () => renderUpdate,
+  renderInitial: () => renderInitial,
+  removed: () => removed,
+  read: () => read,
+  make: () => make,
+  hash: () => hash,
+  empty: () => empty,
+  diffByKey: () => diffByKey,
+  diff: () => diff,
+  combine: () => combine,
+  applyHashDelta: () => applyHashDelta,
+  Values: () => Values,
+  Key: () => Key,
+  Instructions: () => exports_instructions,
+  InitializationBlocked: () => InitializationBlocked,
+  Hash: () => Hash,
+  DuplicateKeyError: () => DuplicateKeyError,
+  Delta: () => Delta
+});
+import { createHash } from "crypto";
+import { Instruction } from "@opencode-ai/schema/instruction";
+import { Data, Effect, Option, Schema } from "effect";
+var Key = Instruction.Key;
+var Hash = Instruction.Hash;
+var Values = Instruction.Values;
+var Delta = Instruction.Delta;
+var NonValue = Data.taggedEnum();
+var unavailable = NonValue.Unavailable();
+var removed = NonValue.Removed();
+
+class InitializationBlocked extends Schema.TaggedErrorClass()("Instructions.InitializationBlocked", { keys: Schema.Array(Key) }) {
+  get message() {
+    return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
+  }
+}
+
+class DuplicateKeyError extends Schema.TaggedErrorClass()("Instructions.DuplicateKeyError", {
+  key: Key
+}) {
+  get message() {
+    return `Duplicate instruction key: ${this.key}`;
+  }
+}
+var empty = [];
+function make(source) {
+  const decode = Schema.decodeUnknownOption(source.codec);
+  const encode = Schema.encodeSync(source.codec);
+  const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
+  const decodeValue = (value) => Option.getOrUndefined(decode(value));
+  return [
+    {
+      key: source.key,
+      read: source.read.pipe(Effect.map((value) => {
+        if (isUnavailable(value))
+          return unavailable;
+        if (isRemoved(value))
+          return removed;
+        return encode(value);
+      })),
+      initial: (value) => {
+        const decoded = decodeValue(value);
+        return decoded === undefined ? undefined : initial(decoded);
+      },
+      changed: (previous, current) => {
+        const before = decodeValue(previous);
+        const after = decodeValue(current);
+        if (after === undefined)
+          return;
+        if (before === undefined)
+          return initial(after);
+        return requireText(source.key, "changed", source.render.changed(before, after));
+      },
+      removed: (previous) => {
+        const decoded = decodeValue(previous);
+        return decoded === undefined || source.render.removed === undefined ? undefined : requireText(source.key, "removed", source.render.removed(decoded));
+      }
+    }
+  ];
+}
+function combine(values) {
+  const sources = values.flat();
+  const keys = new Set;
+  for (const source of sources) {
+    if (keys.has(source.key))
+      throw new DuplicateKeyError({ key: source.key });
+    keys.add(source.key);
+  }
+  return sources;
+}
+function read(value) {
+  return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
+}
+function diff(observed, previous) {
+  const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
+  if (blocked.length > 0)
+    return Effect.fail(new InitializationBlocked({ keys: blocked }));
+  const delta = {};
+  const blobs = {};
+  for (const entry of observed) {
+    if (isUnavailable(entry.value))
+      continue;
+    if (isRemoved(entry.value)) {
+      if (previous && Object.hasOwn(previous, entry.key))
+        delta[entry.key] = Instruction.removed;
+      continue;
+    }
+    const next = hash(entry.value);
+    if (previous?.[entry.key] === next)
+      continue;
+    delta[entry.key] = next;
+    blobs[next] = entry.value;
+  }
+  return Effect.succeed({ delta, blobs });
+}
+function renderInitial(value, values) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(values, source.key))
+      return [];
+    const text = source.initial(values[source.key]);
+    return text === undefined ? [] : [text];
+  }));
+}
+function renderUpdate(value, previous, delta) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(delta, source.key))
+      return [];
+    const current = delta[source.key];
+    if (Option.isNone(current)) {
+      if (!Object.hasOwn(previous, source.key))
+        return [];
+      const text2 = source.removed(previous[source.key]);
+      return text2 === undefined ? [] : [text2];
+    }
+    const next = current.value;
+    const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
+    return text === undefined ? [] : [text];
+  }));
+}
+function hash(value) {
+  return Hash.make(createHash("sha256").update(canonical(value)).digest("hex"));
+}
+function applyHashDelta(values, delta) {
+  const result = { ...values };
+  for (const [key, value] of Object.entries(delta)) {
+    if (value === Instruction.removed)
+      delete result[key];
+    else
+      result[key] = value;
+  }
+  return result;
+}
+function diffByKey(previous, current, key, changed) {
+  const currentKeys = new Set(current.map(key));
+  const previousByKey = new Map(previous.map((value) => [key(value), value]));
+  return {
+    added: current.filter((value) => !previousByKey.has(key(value))),
+    removed: previous.filter((value) => !currentKeys.has(key(value))),
+    changed: current.flatMap((value) => {
+      const before = previousByKey.get(key(value));
+      return before === undefined || !changed(before, value) ? [] : [{ previous: before, current: value }];
+    })
+  };
+}
+function render(parts) {
+  return parts.join(`
+
+`);
+}
+function isUnavailable(value) {
+  return value === unavailable;
+}
+function isRemoved(value) {
+  return value === removed;
+}
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function requireText(key, kind, text) {
+  if (text.length === 0)
+    throw new Error(`Instruction source ${key} rendered an empty ${kind}`);
+  return text;
+}
+
+export { Key, Hash, Values, Delta, unavailable, removed, InitializationBlocked, DuplicateKeyError, empty, make, combine, read, diff, renderInitial, renderUpdate, hash, applyHashDelta, diffByKey, exports_instructions };

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

@@ -0,0 +1,41 @@
+import {
+  EffectSQLiteSession
+} from "./ripgrep-31fzckyb.js";
+import {
+  SQLiteEffectDatabase
+} from "./ripgrep-28q8yd1e.js";
+import {
+  jitCompatCheck
+} from "./ripgrep-ma07p6tt.js";
+
+// src/database/drizzle/effect-sqlite/driver.ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+class EffectSQLiteDatabase extends SQLiteEffectDatabase {
+  static [entityKind] = "EffectSQLiteDatabase";
+}
+var DefaultServices = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+  const client = yield* SqlClient;
+  const cache = yield* EffectCache;
+  const logger = yield* EffectLogger;
+  const dialect = new SQLiteAsyncDialect;
+  const relations = config.relations ?? {};
+  const session = new EffectSQLiteSession(client, dialect, relations, {
+    logger,
+    cache,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  const db = new EffectSQLiteDatabase(dialect, session, relations);
+  db.$client = client;
+  db.$cache.invalidate = cache.onMutate;
+  return db;
+});
+var makeWithDefaults = (config = {}) => make(config).pipe(Effect.provide(DefaultServices));
+
+export { EffectSQLiteDatabase, DefaultServices, make, makeWithDefaults };

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

@@ -0,0 +1,25 @@
+// src/database/migration/20260603141458_session_input_inbox.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603141458_session_input_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_input\` (
+          \`seq\` integer PRIMARY KEY AUTOINCREMENT,
+          \`id\` text NOT NULL UNIQUE,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`seq\`);`);
+    });
+  }
+};
+var _20260603141458_session_input_inbox_default = migration;
+
+export { _20260603141458_session_input_inbox_default };

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

@@ -0,0 +1,137 @@
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/instruction-discovery.ts
+var exports_instruction_discovery = {};
+__export(exports_instruction_discovery, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  InstructionDiscovery: () => exports_instruction_discovery,
+  File: () => File,
+  Event: () => Event
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { createPatch } from "diff";
+class File extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath,
+  content: Schema.String
+}) {
+}
+var Files = Schema.Array(File);
+var key = exports_instructions.Key.make("core/instructions");
+var Event = {
+  Updated: exports_bus.ephemeral({ type: "instruction-discovery.updated", schema: {} })
+};
+var Options = Schema.Struct({
+  project: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/InstructionDiscovery") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const state = exports_state.create({
+    name: "instruction-discovery",
+    initial: () => ({ files: new Map, available: true }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.files.values()),
+      add: (file) => draft.files.set(file.path, new File(file)),
+      update: (path, update) => {
+        const current = draft.files.get(AbsolutePath.make(path));
+        if (!current)
+          return;
+        update(current);
+        current.path = AbsolutePath.make(path);
+      },
+      remove: (path) => draft.files.delete(AbsolutePath.make(path)),
+      unavailable: () => {
+        draft.available = false;
+      }
+    }),
+    finalize: () => bus.publish(Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const source = (value) => exports_instructions.make({
+    key,
+    codec: Schema.toCodecJson(Files),
+    read: Effect.succeed(value),
+    render: {
+      initial: render,
+      changed: renderUpdate,
+      removed: () => "Previously loaded instructions no longer apply."
+    }
+  });
+  const list = Effect.fn("InstructionDiscovery.list")(function* () {
+    const current = state.get();
+    if (!current.available)
+      return exports_instructions.unavailable;
+    return Array.from(current.files.values());
+  });
+  return Service.of({
+    project: options?.project !== false,
+    transform: state.transform,
+    reload: state.reload,
+    list,
+    load: Effect.fn("InstructionDiscovery.load")(function* () {
+      const files = yield* list();
+      if (!Array.isArray(files))
+        return source(files);
+      return source(files.length === 0 ? exports_instructions.removed : files);
+    })
+  });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_bus.node]
+  });
+}
+var node = configured();
+function render(files) {
+  return files.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`);
+}
+function renderUpdate(previous, current) {
+  const changes = exports_instructions.diffByKey(previous, current, (file) => file.path, (before, after) => before.content !== after.content);
+  return [
+    ...changes.removed.map((file) => `The instructions from ${file.path} no longer apply.`),
+    ...changes.added.map((file) => `New instructions apply from:
+${render([file])}`),
+    ...changes.changed.map(({ previous: before, current: after }) => {
+      const patch = createPatch(after.path, before.content, after.content, "", "", { context: 3 });
+      const diff = [
+        `The instructions from ${after.path} changed. Here's the diff:`,
+        "```diff",
+        patch.slice(patch.indexOf("@@")).trimEnd(),
+        "```"
+      ].join(`
+`);
+      const replacement = `The instructions changed:
+${render([after])}`;
+      return diff.length < replacement.length ? diff : replacement;
+    })
+  ].join(`
+
+`);
+}
+
+export { File, Event, Options, Service, layer, configured, node, exports_instruction_discovery };

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

@@ -0,0 +1,58 @@
+// src/database/migration/20260510033149_session_usage.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260510033149_session_usage",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`cost\` real DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_input\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_output\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_reasoning\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_read\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`tokens_cache_write\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`
+        UPDATE session
+        SET
+          cost = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.cost'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_input = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.input'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_output = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.output'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_reasoning = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.reasoning'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_cache_read = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.read'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0),
+          tokens_cache_write = coalesce((
+            SELECT sum(coalesce(json_extract(message.data, '$.tokens.cache.write'), 0))
+            FROM message
+            WHERE message.session_id = session.id
+              AND json_extract(message.data, '$.role') = 'assistant'
+          ), 0)
+      `);
+    });
+  }
+};
+var _20260510033149_session_usage_default = migration;
+
+export { _20260510033149_session_usage_default };