@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-q8bcy8ws.js

@@ -0,0 +1,226 @@
+import {
+  resolveNullableObjectPaths2,
+  mapResultRow2
+} from "./repository-emrn6kk6.js";
+import {
+  SQLiteEffectDatabase2
+} from "./repository-5n0sh9d6.js";
+
+// src/database/drizzle/sqlite-core/effect/session.ts
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { NoopCache, strategyFor } from "drizzle-orm/cache/core/cache";
+import { EffectDrizzleQueryError, EffectTransactionRollbackError } from "drizzle-orm/effect-core/errors";
+import { entityKind, is } from "drizzle-orm/entity";
+import { makeJitRqbMapper } from "drizzle-orm/relations";
+import { fillPlaceholders } from "drizzle-orm/sql/sql";
+import { assertUnreachable, makeJitQueryMapper } from "drizzle-orm/utils";
+class SQLiteEffectPreparedQuery2 {
+  executor;
+  query;
+  logger;
+  cache;
+  queryMetadata;
+  fields;
+  useJitMappers;
+  customResultMapper;
+  isRqbV2Query;
+  rqbConfig;
+  isInTransaction;
+  static [entityKind] = "SQLiteEffectPreparedQuery";
+  joinsNotNullableMap;
+  jitMapper;
+  cacheConfig;
+  effectExecuteMethod;
+  constructor(executor, query, logger, cache, queryMetadata, cacheConfig, fields, executeMethod, useJitMappers, customResultMapper, isRqbV2Query, rqbConfig, isInTransaction = Effect.succeed(false)) {
+    this.executor = executor;
+    this.query = query;
+    this.logger = logger;
+    this.cache = cache;
+    this.queryMetadata = queryMetadata;
+    this.fields = fields;
+    this.useJitMappers = useJitMappers;
+    this.customResultMapper = customResultMapper;
+    this.isRqbV2Query = isRqbV2Query;
+    this.rqbConfig = rqbConfig;
+    this.isInTransaction = isInTransaction;
+    this.effectExecuteMethod = executeMethod;
+    this.cacheConfig = cache.strategy() === "all" && cacheConfig === undefined ? { enabled: true, autoInvalidate: true } : cacheConfig;
+    if (!this.cacheConfig?.enabled) {
+      this.cacheConfig = undefined;
+    }
+  }
+  run(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "run");
+  }
+  all(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.allRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "all");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapAllResult(rows));
+  }
+  get(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.getRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "get");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapGetResult(rows));
+  }
+  values(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "values");
+  }
+  execute(placeholderValues) {
+    return this[this.effectExecuteMethod](placeholderValues);
+  }
+  mapRunResult(result, _isFromBatch) {
+    return result;
+  }
+  mapAllResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return rows;
+    }
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))(rows) : this.customResultMapper(rows);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper(rows);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, resolveNullableObjectPaths2(this.fields, this.joinsNotNullableMap)))(rows) : rows.map((row) => mapResultRow2(this.fields, row, this.joinsNotNullableMap));
+  }
+  mapGetResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return Array.isArray(rows) ? rows[0] : rows;
+    }
+    const row = Array.isArray(rows) ? rows[0] : rows;
+    if (!row)
+      return;
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))([
+        row
+      ]) : this.customResultMapper([row]);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper([row]);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, resolveNullableObjectPaths2(this.fields, this.joinsNotNullableMap)))([row])[0] : mapResultRow2(this.fields, row, this.joinsNotNullableMap);
+  }
+  allRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "all", (rows) => this.mapAllResult(rows));
+  }
+  getRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "get", (row) => row === undefined ? undefined : this.mapGetResult(row));
+  }
+  executeWithCache(placeholderValues, executeMethod, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      yield* this.logger.logQuery(this.query.sql, params);
+      return yield* this.queryWithCache(this.query.sql, params, Effect.suspend(() => this.executor(params, executeMethod)), mapResult);
+    });
+  }
+  mapCachedResult(result, mapResult) {
+    if (!mapResult)
+      return Effect.succeed(result);
+    return Effect.try({
+      try: () => mapResult(result),
+      catch: (cause) => cause
+    });
+  }
+  queryWithCache(queryString, params, query, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      if (this.queryMetadata?.type === "select" && this.cacheConfig?.enabled && (yield* this.isInTransaction)) {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      const cacheStrat = !is(this.cache.cache, NoopCache) ? yield* Effect.tryPromise(() => strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)) : { type: "skip" };
+      if (cacheStrat.type === "skip") {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      if (cacheStrat.type === "invalidate") {
+        const result = yield* query;
+        yield* this.cache.onMutate({ tables: cacheStrat.tables });
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      if (cacheStrat.type === "try") {
+        if (yield* this.isInTransaction) {
+          return yield* this.mapCachedResult(yield* query, mapResult);
+        }
+        const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+        const fromCache = yield* this.cache.get(key, tables, isTag, autoInvalidate);
+        if (typeof fromCache !== "undefined") {
+          return yield* this.mapCachedResult(fromCache, mapResult);
+        }
+        const result = yield* query;
+        yield* this.cache.put(key, result, autoInvalidate ? tables : [], isTag, config);
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      assertUnreachable(cacheStrat);
+    }).pipe(Effect.mapError((e) => new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) })));
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, isFromBatch) {
+    switch (this.effectExecuteMethod) {
+      case "run": {
+        return this.mapRunResult(response, isFromBatch);
+      }
+      case "all": {
+        return this.mapAllResult(response, isFromBatch);
+      }
+      case "get": {
+        return this.mapGetResult(response, isFromBatch);
+      }
+    }
+  }
+}
+
+class SQLiteEffectSession2 {
+  dialect;
+  static [entityKind] = "SQLiteEffectSession";
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  prepareOneTimeQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return this.prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig);
+  }
+  prepareOneTimeRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return this.prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config);
+  }
+  run(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "run").run();
+  }
+  all(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").all();
+  }
+  get(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "get").get();
+  }
+  values(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").values();
+  }
+  count(query) {
+    return this.values(query).pipe(Effect.map((result) => result[0]?.[0] ?? 0));
+  }
+}
+
+class SQLiteEffectTransaction2 extends SQLiteEffectDatabase2 {
+  relations;
+  static [entityKind] = "SQLiteEffectTransaction";
+  constructor(dialect, session, relations) {
+    super(dialect, session, relations);
+    this.relations = relations;
+  }
+  rollback() {
+    return new EffectTransactionRollbackError;
+  }
+}
+
+export { SQLiteEffectPreparedQuery2, SQLiteEffectSession2, SQLiteEffectTransaction2 };

package/dist/chunks/repository-q8rd9qhs.js

@@ -0,0 +1,145 @@
+import {
+  ephemeral2,
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Key3,
+  unavailable3,
+  removed2,
+  make20,
+  diffByKey2
+} from "./repository-rhjbct0v.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/instruction-discovery.ts
+var exports_instruction_discovery = {};
+__export(exports_instruction_discovery, {
+  Event: () => Event8,
+  File: () => File2,
+  InstructionDiscovery: () => exports_instruction_discovery,
+  Options: () => Options6,
+  Service: () => Service39,
+  configured: () => configured6,
+  layer: () => layer16,
+  node: () => node43
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { createPatch } from "diff";
+class File2 extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath2,
+  content: Schema.String
+}) {
+}
+var Files = Schema.Array(File2);
+var key = Key3.make("core/instructions");
+var Event8 = {
+  Updated: ephemeral2({ type: "instruction-discovery.updated", schema: {} })
+};
+var Options6 = Schema.Struct({
+  project: Schema.optional(Schema.Boolean),
+  global: Schema.optional(Schema.Boolean)
+});
+
+class Service39 extends Context.Service()("@opencode/InstructionDiscovery") {
+}
+var layer16 = (options) => Layer.effect(Service39, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const state = create3({
+    name: "instruction-discovery",
+    initial: () => ({ files: new Map, available: true }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.files.values()),
+      add: (file) => editor.files.set(file.path, new File2(file)),
+      update: (path, update) => {
+        const current = editor.files.get(AbsolutePath2.make(path));
+        if (!current)
+          return;
+        update(current);
+        current.path = AbsolutePath2.make(path);
+      },
+      remove: (path) => editor.files.delete(AbsolutePath2.make(path)),
+      unavailable: () => {
+        editor.available = false;
+      }
+    }),
+    notify: () => bus.publish(Event8.Updated, {}).pipe(Effect.asVoid)
+  });
+  const source = (value) => make20({
+    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 unavailable3;
+    return Array.from(current.files.values());
+  });
+  return Service39.of({
+    project: options?.project !== false,
+    global: options?.global !== 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 ? removed2 : files);
+    })
+  });
+}));
+function configured6(options) {
+  return makeLocationNode({
+    service: Service39,
+    layer: layer16(options),
+    deps: [node83]
+  });
+}
+var node43 = configured6();
+function render(files) {
+  return files.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`);
+}
+function renderUpdate(previous, current) {
+  const changes = diffByKey2(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 { File2, Event8, Options6, Service39, layer16, configured6, node43, exports_instruction_discovery };

package/dist/chunks/repository-qapv375x.js

@@ -0,0 +1,4 @@
+// src/pty/schema.ts
+import { ID as ID3 } from "@opencode/schema/pty";
+
+export { ID3 };

package/dist/chunks/repository-qaymkmh1.js

@@ -0,0 +1,14 @@
+// src/util/which.ts
+import whichPkg from "which";
+import path from "path";
+function which2(cmd, env, bin) {
+  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
+  const full = base && bin ? base + path.delimiter + bin : base || bin;
+  return whichPkg.sync(cmd, {
+    nothrow: true,
+    path: full,
+    pathExt: env?.PATHEXT ?? env?.PathExt ?? process.env.PATHEXT ?? process.env.PathExt
+  });
+}
+
+export { which2 };

package/dist/chunks/repository-qb87gjwd.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260819222447_session_viewed_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260819222447_session_viewed_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_idle\` integer;`);
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_viewed\` integer;`);
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`idle_outcome\` text;`);
+    });
+  }
+};
+var _20260819222447_session_viewed_state_default = migration;
+
+export { _20260819222447_session_viewed_state_default };

package/dist/chunks/repository-qec2v6cx.js

@@ -0,0 +1,247 @@
+import {
+  node65
+} from "./repository-b5n11jz6.js";
+import {
+  node76
+} from "./repository-c9wtqnwj.js";
+import {
+  node82
+} from "./repository-yz39bey7.js";
+import {
+  node78
+} from "./repository-0zkv00cg.js";
+import {
+  node77
+} from "./repository-gtm8txn9.js";
+import {
+  node73
+} from "./repository-3tamc9js.js";
+import {
+  node70,
+  boundNode2
+} from "./repository-6wjjjhy6.js";
+import {
+  configured8,
+  node49
+} from "./repository-smnv2tch.js";
+import {
+  node69
+} from "./repository-3mdgf1e2.js";
+import {
+  node26
+} from "./repository-h0gkjmvb.js";
+import {
+  node17
+} from "./repository-58e8mpmb.js";
+import {
+  node28
+} from "./repository-penaav09.js";
+import {
+  node27
+} from "./repository-j38hs89b.js";
+import {
+  node75
+} from "./repository-fmdgzt8c.js";
+import {
+  node74
+} from "./repository-4emgtgzt.js";
+import {
+  node85
+} from "./repository-drknmmyh.js";
+import {
+  node36
+} from "./repository-3yetcf2r.js";
+import {
+  Service52,
+  node56
+} from "./repository-1bvekr7f.js";
+import {
+  node40
+} from "./repository-pctvcs1g.js";
+import {
+  node66
+} from "./repository-mgx963cj.js";
+import {
+  node62
+} from "./repository-ykpr0q7c.js";
+import {
+  node55
+} from "./repository-y973e7aq.js";
+import {
+  configured6,
+  node43
+} from "./repository-q8rd9qhs.js";
+import {
+  node42
+} from "./repository-a8ygtzbq.js";
+import {
+  node46
+} from "./repository-39fveamk.js";
+import {
+  node35
+} from "./repository-zr3d0gxg.js";
+import {
+  node59
+} from "./repository-z0xnky3q.js";
+import {
+  node37
+} from "./repository-ext3js1z.js";
+import {
+  node45
+} from "./repository-9xb0s4b9.js";
+import {
+  node38
+} from "./repository-2m84dfka.js";
+import {
+  node33
+} from "./repository-h1rn3ct5.js";
+import {
+  node52
+} from "./repository-bejabbw1.js";
+import {
+  node61
+} from "./repository-3ke3s58r.js";
+import {
+  node68
+} from "./repository-ky16kd9n.js";
+import {
+  node47
+} from "./repository-rsbh8q26.js";
+import {
+  node19
+} from "./repository-2v08kgv1.js";
+import {
+  node21
+} from "./repository-xp6wb0v9.js";
+import {
+  node25
+} from "./repository-0k7wafs3.js";
+import {
+  node22
+} from "./repository-cedwm630.js";
+import {
+  node18
+} from "./repository-qt3bdkqw.js";
+import {
+  node14
+} from "./repository-txzqvs6q.js";
+import {
+  node23
+} from "./repository-pvp1cs2e.js";
+import {
+  node7,
+  bound2
+} from "./repository-cmwkp3r5.js";
+import {
+  node13
+} from "./repository-jzksghxf.js";
+import {
+  node12
+} from "./repository-pzjh8mr9.js";
+import {
+  node5
+} from "./repository-x384g1hs.js";
+import {
+  node3
+} from "./repository-t59s3hhv.js";
+import {
+  node2
+} from "./repository-9rs4eqfv.js";
+import {
+  node24
+} from "./repository-r2dfp6se.js";
+import {
+  node11
+} from "./repository-me4pxbk2.js";
+import {
+  node10
+} from "./repository-my7gf51c.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/instance.ts
+var exports_instance = {};
+__export(exports_instance, {
+  Instance: () => exports_instance,
+  Service: () => Service52,
+  graph: () => graph2,
+  layer: () => layer2,
+  node: () => node56
+});
+import { Effect, Layer } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Node } from "@opencode/util/effect/app-node";
+var nodes = [
+  node70,
+  node69,
+  node49,
+  node65,
+  node73,
+  node59,
+  node19,
+  node25,
+  node78,
+  node77,
+  node75,
+  node76,
+  node18,
+  node66,
+  node7,
+  node3,
+  node2,
+  node22,
+  node28,
+  node27,
+  node61,
+  node24,
+  node47,
+  node45,
+  node42,
+  node43,
+  node23,
+  node26,
+  node17,
+  node36,
+  node62,
+  node46,
+  node68,
+  node85,
+  node38,
+  node37,
+  node40,
+  node82,
+  node74,
+  node5,
+  node35,
+  node12,
+  node55,
+  node13,
+  node11,
+  node33,
+  node52,
+  node10,
+  node21,
+  node14
+];
+var graph2 = LayerNode.group(nodes);
+var vanillaReplacements = [
+  node49.replace(configured8({ project: false, global: false })),
+  node43.replace(configured6({ project: false, global: false }))
+];
+function layer2(ref, options = {}) {
+  const startedAt = performance.now();
+  const replacements = [
+    ...options.discovery === false ? vanillaReplacements : [],
+    ...options.replacements ?? [],
+    node70.replace(boundNode2(ref, { discovery: options.discovery })),
+    node7.replace(bound2(options.plugins ?? []))
+  ];
+  return LayerNode.compile(graph2, { replacements, shared: Node.tags.values.global }).pipe(Layer.orDie, Layer.tap(() => Effect.logInfo("location services booted", {
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    durationMs: Math.round(performance.now() - startedAt)
+  })));
+}
+
+export { graph2, layer2, exports_instance };

package/dist/chunks/repository-qfa1cgps.js

@@ -0,0 +1,8 @@
+// src/database/schema.sql.ts
+import { integer } from "drizzle-orm/sqlite-core";
+var Timestamps2 = {
+  time_created: integer().notNull().$default(() => Date.now()),
+  time_updated: integer().notNull().$onUpdate(() => Date.now())
+};
+
+export { Timestamps2 };