@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-6tpt9h9q.js

@@ -0,0 +1,184 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Service52,
+  node56
+} from "./repository-1bvekr7f.js";
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  Service67,
+  node71
+} from "./repository-1g6ktzxp.js";
+import {
+  Ref2
+} from "./repository-6wjjjhy6.js";
+import {
+  Service53,
+  node57
+} from "./repository-2yv9jfkc.js";
+import {
+  SessionMessage2
+} from "./repository-gftt206x.js";
+import {
+  NotFoundError7
+} from "./repository-3x8gcmrs.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  Service49
+} from "./repository-8gxqpgph.js";
+import {
+  Service60,
+  node64
+} from "./repository-1n274c67.js";
+import {
+  Item2,
+  serialized2,
+  Service50,
+  node54,
+  moveIDs2
+} from "./repository-0wjw63yk.js";
+import {
+  Service48,
+  node53
+} from "./repository-2fbr18f9.js";
+import {
+  node32
+} from "./repository-9yhr46n3.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/move.ts
+var exports_move = {};
+__export(exports_move, {
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  Service: () => Service27,
+  SessionMove: () => exports_move,
+  node: () => node31
+});
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import path from "path";
+class DestinationNotFoundError2 extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationNotDirectoryError2 extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationUnavailableError2 extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath2 }) {
+}
+
+class Service27 extends Context.Service()("@opencode/SessionMove") {
+}
+var layer = Layer.effect(Service27, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const projects = yield* Service67;
+  const locations = yield* Service53;
+  const store = yield* Service60;
+  const execution = yield* Service48;
+  const instances = yield* Service52;
+  const admission = yield* Service50;
+  const database = yield* Service79;
+  const bus = yield* Service78;
+  const get = Effect.fn("SessionMove.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError7({ sessionID });
+    return session;
+  });
+  const resolveDestination = Effect.fn("SessionMove.resolveDestination")(function* (session, input) {
+    const value = input.directory.trim();
+    const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
+    const directory = AbsolutePath2.make(path.resolve(session.location.directory, expanded));
+    const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!info)
+      return yield* new DestinationNotFoundError2({ directory });
+    if (info.type !== "Directory")
+      return yield* new DestinationNotDirectoryError2({ directory });
+    const project = yield* projects.resolve(directory);
+    const destination = {
+      location: Ref2.make({ directory, workspaceID: input.workspaceID }),
+      projectID: project.id,
+      subpath: RelativePath2.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+    };
+    yield* locations.contextEffect(destination.location).pipe(Effect.scoped, Effect.catchCause((cause) => {
+      if (Cause.hasInterruptsOnly(cause))
+        return Effect.failCause(cause);
+      return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError2({ directory }))));
+    }));
+    return destination;
+  });
+  const sourceUnavailable = Effect.fn("SessionMove.sourceUnavailable")(function* (session) {
+    if (yield* execution.isActive(session.id))
+      return false;
+    if (!(yield* fs.isDir(session.location.directory)))
+      return true;
+    return yield* Service49.pipe(instances.provide(session), Effect.as(false), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.succeed(true)));
+  });
+  return Service27.of({
+    move: Effect.fn("SessionMove.move")(function* (input) {
+      const session = yield* get(input.sessionID);
+      const destination = yield* resolveDestination(session, input);
+      const unavailable = yield* sourceUnavailable(session);
+      const item = Item2.make({
+        type: "move",
+        payload: destination,
+        delivery: input.delivery ?? "steer"
+      });
+      yield* serialized2(input.sessionID, Effect.gen(function* () {
+        const latest = yield* get(input.sessionID);
+        if (unavailable && latest.location.directory === session.location.directory && latest.location.workspaceID === session.location.workspaceID && !(yield* execution.isActive(input.sessionID))) {
+          const cancellations = (yield* moveIDs2(database.db, input.sessionID)).map((item) => [SessionEvent2.InboxCancelled, { sessionID: input.sessionID, inboxID: item.id }]);
+          const moved = [SessionEvent2.Moved, { sessionID: input.sessionID, ...destination }];
+          const first = cancellations[0];
+          if (!first)
+            return yield* bus.publish(...moved).pipe(Effect.asVoid);
+          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
+        }
+        yield* admission.admit({
+          id: SessionMessage2.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    })
+  });
+}));
+var node31 = makeGlobalNode({
+  service: Service27,
+  layer,
+  deps: [
+    FSUtil.node,
+    Global.node,
+    node71,
+    node57,
+    node64,
+    node53,
+    node56,
+    node54,
+    node84,
+    node83,
+    node32
+  ]
+});
+
+export { DestinationNotFoundError2, DestinationNotDirectoryError2, DestinationUnavailableError2, Service27, node31, exports_move };

package/dist/chunks/repository-6wjjjhy6.js

@@ -0,0 +1,43 @@
+import {
+  Service67,
+  node71
+} from "./repository-1g6ktzxp.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/location.ts
+var exports_location = {};
+__export(exports_location, {
+  Info: () => Info24,
+  Location: () => exports_location,
+  Ref: () => Ref2,
+  Service: () => Service66,
+  boundNode: () => boundNode2,
+  node: () => node70,
+  response: () => response2
+});
+import { Context, Effect, Layer } from "effect";
+import { Info as Info24, Ref as Ref2, response as response2 } from "@opencode/schema/location";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { makeLocationNode, tags } from "@opencode/util/effect/app-node";
+class Service66 extends Context.Service()("@opencode/Location") {
+}
+var node70 = LayerNode.unbound(Service66, tags.values.location);
+var layer = (ref, options) => Layer.effect(Service66, Effect.gen(function* () {
+  const project = yield* Service67;
+  const resolved = yield* project.resolve(ref.directory, options);
+  return Service66.of({
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    project: { id: resolved.id, directory: resolved.directory, canonical: resolved.canonical },
+    vcs: resolved.vcs
+  });
+}));
+var boundNode2 = (ref, options) => makeLocationNode({
+  service: Service66,
+  layer: layer(ref, options),
+  deps: [node71]
+});
+
+export { Info24, Ref2, response2, Service66, node70, boundNode2, exports_location };

package/dist/chunks/repository-71q4at8m.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./repository-ym463w8f.js";
+
+// src/plugin/provider/alibaba.ts
+var AlibabaPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.alibaba",
+  package: "@ai-sdk/alibaba",
+  load: async (options) => {
+    const { createAlibaba } = await import("@ai-sdk/alibaba");
+    return createAlibaba(options);
+  }
+});
+
+export { AlibabaPlugin2 };

package/dist/chunks/repository-72ds7gf6.js

@@ -0,0 +1,101 @@
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  Service22,
+  readText2,
+  syncTextBom2
+} from "./repository-h0gkjmvb.js";
+import {
+  Service14
+} from "./repository-58e8mpmb.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19
+} from "./repository-pvp1cs2e.js";
+import {
+  fileDiff2
+} from "./repository-6prwharc.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/write.ts
+var exports_write = {};
+__export(exports_write, {
+  Input: () => Input2,
+  Output: () => Output2,
+  Plugin: () => Plugin19,
+  WriteTool: () => exports_write,
+  name: () => name2,
+  toModelContent: () => toModelContent2
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+var name2 = "write";
+var Input2 = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "Path to the file to write to"
+  }),
+  content: Schema.String.annotate({ description: "Content to write to the file" })
+});
+var Output2 = Schema.Struct({
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean
+});
+var toModelContent2 = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin19 = {
+  id: "opencode.tool.write",
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
+    const access = yield* Service19;
+    const fileMutation = yield* Service22;
+    const environment = yield* Service65;
+    const formatter = yield* Service14;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name2,
+      options: { codemode: false, permission: "edit" },
+      description: `Writes a file to the local filesystem, overwriting if one exists.
+
+Missing parent directories are created automatically.
+
+Use this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.`,
+      input: Input2,
+      output: Output2,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const target = yield* access.resolve({ path: input.path, kind: "file" });
+        yield* access.authorizeExternal([target], context);
+        const current = yield* readText2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.undefined));
+        const next = Bom.split(input.content);
+        const preview = fileDiff2(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        yield* permission.assert({
+          action: "edit",
+          resources: [target.resource],
+          save: ["*"],
+          metadata: { files: [preview] },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
+        const bom = (yield* readText2(environment.files, target.absolute)).bom;
+        if (yield* formatter.file(target.absolute)) {
+          yield* syncTextBom2(environment.files, target.absolute, bom);
+        }
+        return result;
+      }).pipe(Effect.map((output) => ({ output, content: toModelContent2(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name2, Input2, Output2, toModelContent2, Plugin19, exports_write };

package/dist/chunks/repository-7akdwqpd.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260601010001_normalize_storage_paths.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601010001_normalize_storage_paths",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`UPDATE project SET worktree = REPLACE(worktree, char(92), '/') WHERE worktree GLOB '[A-Za-z]:' || char(92) || '*' OR worktree LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE project SET sandboxes = REPLACE(sandboxes, char(92) || char(92), '/') WHERE instr(sandboxes, char(92)) > 0 AND (worktree GLOB '[A-Za-z]:*' OR worktree LIKE '//%');`);
+      yield* tx.run(`UPDATE session SET directory = REPLACE(directory, char(92), '/') WHERE directory GLOB '[A-Za-z]:' || char(92) || '*' OR directory LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE session SET path = REPLACE(path, char(92), '/') WHERE path IS NOT NULL AND instr(path, char(92)) > 0 AND (directory GLOB '[A-Za-z]:*' OR directory LIKE '//%');`);
+    });
+  }
+};
+var _20260601010001_normalize_storage_paths_default = migration;
+
+export { _20260601010001_normalize_storage_paths_default };

package/dist/chunks/repository-7bmhse3q.js

@@ -0,0 +1,118 @@
+import {
+  getTableColumnsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2
+} from "./repository-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/insert.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SQL, sql } from "drizzle-orm/sql/sql";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { haveSameKeys } from "drizzle-orm/utils";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+class SQLiteEffectInsertBuilder2 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectInsertBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    return new SQLiteEffectInsertBase2(this.table, values, this.session, this.dialect, this.withList);
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime2(this.table), select._.selectedFields)) {
+      throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
+    }
+    return new SQLiteEffectInsertBase2(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+}
+
+class SQLiteEffectInsertBase2 {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectInsert";
+  config;
+  constructor(table, values, effectSession, effectDialect, withList, select) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, values, withList, select };
+  }
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
+    return this;
+  }
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    if (config.target === undefined) {
+      this.config.onConflict.push(sql` on conflict do nothing`);
+      return this;
+    }
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const whereSql = config.where ? sql` where ${config.where}` : sql``;
+    this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    if (config.where && (config.targetWhere || config.setWhere)) {
+      throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
+    }
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    const whereSql = config.where ? sql` where ${config.where}` : undefined;
+    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
+    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet2(this.config.table, config.set));
+    this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildInsertQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "insert",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectInsertBase2);
+
+export { SQLiteEffectInsertBuilder2, SQLiteEffectInsertBase2 };

package/dist/chunks/repository-7m9af43g.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260312043431_session_message_cursor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260312043431_session_message_cursor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`message_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`part_message_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`message_session_time_created_id_idx\` ON \`message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`part_message_id_id_idx\` ON \`part\` (\`message_id\`,\`id\`);`);
+    });
+  }
+};
+var _20260312043431_session_message_cursor_default = migration;
+
+export { _20260312043431_session_message_cursor_default };