@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-cabt264k.js

@@ -0,0 +1,74 @@
+import {
+  Service79
+} from "./repository-8m31s27t.js";
+import {
+  Service52
+} from "./repository-1bvekr7f.js";
+import {
+  awaitActivation2
+} from "./repository-jqh9b0xq.js";
+import {
+  provenance2
+} from "./repository-msq0jde0.js";
+import {
+  preview2
+} from "./repository-j8g7a3j8.js";
+import {
+  baseTranscript2
+} from "./repository-g0dr00md.js";
+import {
+  Service28
+} from "./repository-h1rn3ct5.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  generate: () => generate3
+});
+import { LLMClient, Message } from "@opencode/ai";
+import { Effect } from "effect";
+var generate3 = Effect.fn("SessionGenerate.generate")(function* (input) {
+  const instances = yield* Service52;
+  const database = yield* Service79;
+  const llm = yield* LLMClient.Service;
+  return yield* Effect.gen(function* () {
+    yield* awaitActivation2;
+    const context = yield* Service28;
+    const selection = yield* context.select(input.session.id);
+    const model = yield* context.resolveModel(selection.session);
+    const history = yield* preview2(database.db, selection.session.id, selection.instructions, provenance2(model) ?? "local");
+    const transcript = baseTranscript2({
+      agent: selection.agent.info,
+      model,
+      tools: selection.tools,
+      initial: history.initial,
+      messages: history.messages
+    });
+    const prepared = yield* context.request.generate({
+      session: selection.session,
+      agent: selection.agent.id,
+      model,
+      tools: selection.tools,
+      system: transcript.system,
+      messages: [
+        ...transcript.messages,
+        ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+        Message.user(input.prompt)
+      ]
+    });
+    yield* Effect.logInfo("sending session generation request", {
+      sessionID: selection.session.id,
+      providerID: model.ref.providerID,
+      modelID: model.ref.id
+    });
+    const response = yield* llm.generate(prepared.request, prepared.options);
+    yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+    return response.text;
+  }).pipe(instances.provide(input.session));
+});
+
+export { generate3, exports_generate };

package/dist/chunks/repository-cedwm630.js

@@ -0,0 +1,285 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  WorktreeError2,
+  node72
+} from "./repository-1gnhqkth.js";
+import {
+  ID12
+} from "./repository-hqjg1cx1.js";
+import {
+  Slug2
+} from "./repository-gebd4c9n.js";
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  ProjectTable2
+} from "./repository-8p4f9s12.js";
+import {
+  WorktreeTable2
+} from "./repository-cfpkc3c9.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  DirectoryUnavailableError2,
+  canonical2
+} from "./repository-gv6a8nnw.js";
+import {
+  make12
+} from "./repository-ehajtz8g.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/worktree.ts
+var exports_worktree2 = {};
+__export(exports_worktree2, {
+  CreateInput: () => CreateInput2,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  Event: () => Event4,
+  Info: () => Info4,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  OperationError: () => OperationError2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service18,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
+  UnsupportedLocationError: () => UnsupportedLocationError2,
+  Worktree: () => exports_worktree2,
+  node: () => node22
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode/util/fs-util";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Global } from "@opencode/util/global";
+import { Worktree } from "@opencode/schema/worktree";
+import { AppProcess } from "@opencode/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { OperationError as OperationError2 } from "@opencode/schema/worktree";
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput2 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info4 = Worktree.Info;
+var List2 = Worktree.List;
+var ListEntry3 = Worktree.ListEntry;
+
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID12, directory: Schema.optional(AbsolutePath2) }) {
+}
+
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
+}
+
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
+}
+
+class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
+}
+var Event4 = Worktree.Event;
+
+class Service18 extends Context.Service()("@opencode/v2/Worktree") {
+}
+var layer = Layer.effect(Service18, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const database = yield* Service79;
+  const db = database.db;
+  const bus = yield* Service78;
+  const processService = yield* AppProcess.Service;
+  const location = yield* Service66;
+  const global = yield* Global.Service;
+  const projectID = location.project.id;
+  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const gitStrategy = yield* make12;
+  const state = create3({
+    name: "worktree",
+    initial: () => ({
+      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
+      strategies: new Map([[gitStrategy.id, gitStrategy]]),
+      selected: gitStrategy.id
+    }),
+    editor: (value) => ({
+      configure: (settings) => {
+        value.directory = settings.directory;
+      },
+      add: (strategy) => {
+        value.strategies.delete(strategy.id);
+        value.strategies.set(strategy.id, strategy);
+        value.selected = strategy.id;
+      }
+    })
+  });
+  const changed = Effect.fnUntraced(function* (update) {
+    if (update)
+      yield* bus.publish(Event4.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fnUntraced(function* () {
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (directory) {
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+      project_id: projectID,
+      directory: input.directory,
+      strategy: input.strategy
+    }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
+      set: {
+        strategy: input.strategy ?? null
+      },
+      setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+  };
+  const source = Effect.fnUntraced(function* (input) {
+    const sourceDirectory = input ?? location.project.directory;
+    const resolved = yield* canonical2(fs, sourceDirectory);
+    if ((yield* ops.find(resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id, strategies) {
+    const found = strategies.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError2({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input = {}) {
+    yield* local;
+    const current = state.get();
+    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
+    const directory = input.directory ?? current.directory;
+    const sourceDirectory = yield* source(input.from);
+    yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug2.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath2.make(path.join(directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(directory, `${name}-${suffix}`));
+    }
+    const created = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory,
+      branch: input.branch
+    }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
+    const result = { directory: yield* canonical2(fs, created.directory) };
+    yield* changed(yield* ops.create({
+      directory: result.directory,
+      strategy: selected.id,
+      replace: true
+    }));
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    const command = project?.commands?.start?.trim();
+    if (command) {
+      const windows = process.platform === "win32";
+      yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
+        cwd: result.directory,
+        env: {
+          OPENCODE_WORKTREE_BASE: sourceDirectory,
+          OPENCODE_WORKTREE_PATH: result.directory
+        },
+        extendEnv: true,
+        stdin: "ignore",
+        shell: windows
+      })).pipe(Effect.flatMap(AppProcess.requireSuccess));
+    }
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    yield* local;
+    const worktreeDirectory = yield* canonical2(fs, input.directory);
+    const stored = yield* ops.find(worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    yield* strategy.remove({
+      directory: worktreeDirectory,
+      force: input.force
+    }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
+    yield* changed(yield* ops.remove(worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* () {
+    yield* local;
+    const stored = yield* ops.list();
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const discovered = new Map;
+    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+      for (const strategy of strategies) {
+        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        for (const entry of entries) {
+          const directory = yield* canonical2(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
+          if (!directory || discovered.has(directory))
+            continue;
+          discovered.set(directory, {
+            directory,
+            strategy: entry.type === "worktree" ? strategy.id : undefined
+          });
+        }
+      }
+    }
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const changes = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+    })).pipe(Effect.orDie);
+    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service18.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Worktree.list")(function* () {
+      yield* refresh();
+      return yield* ops.list();
+    }),
+    create,
+    remove,
+    refresh
+  });
+}));
+var node22 = makeLocationNode({
+  service: Service18,
+  layer,
+  deps: [FSUtil.node, node72, node83, node84, AppProcess.node, node70, Global.node]
+});
+function operationError(strategy, operation, error) {
+  if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
+    return error;
+  return new Worktree.OperationError({
+    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`
+  });
+}
+
+export { StrategyID2, CreateInput2, RemoveInput2, RefreshResult2, Info4, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event4, Service18, node22, exports_worktree2, OperationError2 };

package/dist/chunks/repository-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/repository-cfpkc3c9.js

@@ -0,0 +1,17 @@
+import {
+  absoluteColumn2
+} from "./repository-6msgmcgs.js";
+import {
+  ProjectTable2
+} from "./repository-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/repository-cg1ew3t4.js

@@ -0,0 +1,51 @@
+import {
+  ID16,
+  packageName2
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/amazon-bedrock.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var CHAIN_ENV = [
+  "AWS_PROFILE",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_WEB_IDENTITY_TOKEN_FILE",
+  "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
+  "AWS_CONTAINER_CREDENTIALS_FULL_URI"
+];
+var isBedrock = (item) => {
+  const name = packageName2(item.package);
+  return name.startsWith("@ai-sdk/amazon-bedrock") || name.startsWith("@opencode/ai/providers/amazon-bedrock");
+};
+var AmazonBedrockPlugin2 = define({
+  id: "opencode.provider.amazon.bedrock",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: ID16.amazonBedrock,
+        method: { type: "env", names: ["AWS_BEARER_TOKEN_BEDROCK"] }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isBedrock(item.provider))
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          const settings = provider.settings ?? {};
+          const chain = typeof settings.profile === "string" || CHAIN_ENV.some((name) => process.env[name]);
+          if (chain && provider.activation === "auto")
+            provider.activation = "enabled";
+          const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1";
+          provider.settings = {
+            ...settings,
+            ...typeof settings.region !== "string" ? { region } : {},
+            ...typeof settings.baseURL !== "string" && typeof settings.endpoint === "string" ? { baseURL: settings.endpoint } : {}
+          };
+          delete provider.settings.endpoint;
+        });
+      }
+    });
+  })
+});
+
+export { AmazonBedrockPlugin2 };

package/dist/chunks/repository-cmwkp3r5.js

@@ -0,0 +1,32 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/instance.ts
+var exports_instance2 = {};
+__export(exports_instance2, {
+  InstancePlugins: () => exports_instance2,
+  Service: () => Service5,
+  bound: () => bound2,
+  node: () => node7
+});
+import { Context, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+
+class Service5 extends Context.Service()("@opencode/InstancePlugins") {
+}
+var node7 = makeLocationNode({
+  service: Service5,
+  layer: bound2([]),
+  deps: []
+});
+function bound2(plugins) {
+  const duplicates = plugins.filter((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index);
+  if (duplicates.length > 0) {
+    throw new Error(`duplicate instance plugin ids: ${duplicates.map((plugin) => plugin.id).join(", ")}`);
+  }
+  const stamped = plugins.map((plugin) => ({ ...plugin, revision: "instance", source: { type: "sdk" } }));
+  return Layer.succeed(Service5, Service5.of({ all: () => stamped }));
+}
+
+export { Service5, node7, bound2, exports_instance2 };