@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-5cy52y0z.js

@@ -0,0 +1,116 @@
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  toSessionError2
+} from "./repository-ezbaq0hv.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/runner/retry.ts
+var exports_retry = {};
+__export(exports_retry, {
+  SessionRunnerRetry: () => exports_retry,
+  isRetryable: () => isRetryable2,
+  make: () => make9,
+  policy: () => policy2,
+  transient: () => transient2
+});
+import { isContextOverflowFailure } from "@opencode/ai";
+import { Clock, Duration, Effect, Pull, Schedule } from "effect";
+function isRetryable2(error) {
+  const override = error.reason.http?.headers["x-should-retry"];
+  if (override === "true")
+    return true;
+  if (override === "false")
+    return false;
+  switch (error.reason._tag) {
+    case "RateLimit":
+    case "ProviderInternal":
+      return true;
+    case "Transport":
+      return error.reason.delivery !== "accepted" && error.reason.delivery !== "rejected";
+    case "InvalidProviderOutput":
+      return error.reason.classification === "incomplete-stream";
+    case "UnknownProvider":
+      return true;
+    case "Authentication":
+    case "QuotaExceeded":
+    case "ContentPolicy":
+    case "InvalidRequest":
+    case "UnsupportedOperation":
+    case "NoRoute":
+      return false;
+    default: {
+      const exhaustive = error.reason;
+      return exhaustive;
+    }
+  }
+}
+var RETRY_AFTER_MAX = Duration.toMillis("15 minutes");
+var retryAfter = (input) => {
+  if (input.cause.reason._tag === "RateLimit" || input.cause.reason._tag === "ProviderInternal")
+    return input.cause.reason.retryAfterMs === undefined ? undefined : Math.min(input.cause.reason.retryAfterMs, RETRY_AFTER_MAX);
+  return;
+};
+var schedule = Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(Schedule.jittered, Schedule.setInputType(), Schedule.modifyDelay(({ input, duration: delay }) => {
+  const minimum = retryAfter(input);
+  const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum));
+  return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))));
+}));
+var policy2 = (sessionID) => Effect.gen(function* () {
+  const step = yield* Schedule.toStep(schedule);
+  let attempt = 1;
+  return (input) => Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const next = yield* step(now, input).pipe(Pull.catchDone(() => Effect.succeed(undefined)));
+    if (!next)
+      return { retry: false };
+    const [, duration] = next;
+    attempt++;
+    const delay = Math.ceil(Duration.toMillis(duration));
+    const event = {
+      sessionID,
+      agent: input.agent,
+      model: input.model,
+      error: input.error,
+      attempt,
+      decision: input.retry ? { retry: true, delay } : { retry: false }
+    };
+    yield* input.hook(event);
+    if (!event.decision.retry)
+      return event.decision;
+    const normalized = Number.isFinite(event.decision.delay) && event.decision.delay >= 0 ? Math.ceil(event.decision.delay) : delay;
+    return { retry: true, attempt, delay: normalized };
+  });
+});
+var transient2 = (decide, input) => (effect) => Effect.retry(effect, {
+  while: (cause) => Effect.gen(function* () {
+    if (isContextOverflowFailure(cause))
+      return false;
+    const decision = yield* decide({ ...input, cause, error: toSessionError2(cause), retry: isRetryable2(cause) });
+    if (!decision.retry)
+      return false;
+    yield* Effect.sleep(decision.delay);
+    return true;
+  })
+});
+var make9 = (bus, sessionID) => Effect.gen(function* () {
+  const decide = yield* policy2(sessionID);
+  const wait = (input) => Effect.gen(function* () {
+    const scheduled = yield* Clock.currentTimeMillis;
+    yield* bus.publish(SessionEvent2.RetryScheduled, {
+      sessionID,
+      assistantMessageID: input.assistantMessageID,
+      attempt: input.decision.attempt,
+      at: scheduled + input.decision.delay,
+      error: input.error
+    });
+    const remaining = Math.max(0, scheduled + input.decision.delay - (yield* Clock.currentTimeMillis));
+    yield* Effect.sleep(Duration.millis(remaining));
+  });
+  return { decide, wait };
+});
+
+export { isRetryable2, policy2, transient2, make9, exports_retry };

package/dist/chunks/repository-5daktx2q.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/markdown.ts
+var exports_markdown = {};
+__export(exports_markdown, {
+  ConfigMarkdown: () => exports_markdown,
+  parse: () => parse3,
+  parseOption: () => parseOption2,
+  sanitize: () => sanitize2
+});
+import matter from "gray-matter";
+function parse3(content) {
+  try {
+    return matter(content);
+  } catch {
+    return matter(sanitize2(content));
+  }
+}
+function parseOption2(content) {
+  try {
+    return parse3(content);
+  } catch {
+    return;
+  }
+}
+function sanitize2(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match)
+    return content;
+  const frontmatter = match[1];
+  const result = frontmatter.split(/\r?\n/).flatMap((line) => {
+    if (line.trim().startsWith("#") || line.trim() === "" || /^\s+/.test(line))
+      return [line];
+    const entry = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+    if (!entry)
+      return [line];
+    const value = entry[2].trim();
+    if (value === "" || value === ">" || value === "|" || value.startsWith('"') || value.startsWith("'"))
+      return [line];
+    if (!value.includes(":"))
+      return [line];
+    return [`${entry[1]}: |-`, `  ${value}`];
+  });
+  return content.replace(frontmatter, () => result.join(`
+`));
+}
+
+export { parse3, parseOption2, sanitize2, exports_markdown };

package/dist/chunks/repository-5n0sh9d6.js

@@ -0,0 +1,137 @@
+import {
+  SQLiteEffectCountBuilder2
+} from "./repository-f0mxakyp.js";
+import {
+  SQLiteEffectDeleteBase2
+} from "./repository-w3wsvvr9.js";
+import {
+  SQLiteEffectInsertBuilder2
+} from "./repository-7bmhse3q.js";
+import {
+  SQLiteEffectRelationalQueryBuilder2
+} from "./repository-cf4snx6d.js";
+import {
+  SQLiteEffectRaw2
+} from "./repository-822emrt2.js";
+import {
+  SQLiteEffectSelectBuilder2
+} from "./repository-wd87259q.js";
+import {
+  SQLiteEffectUpdateBuilder2
+} from "./repository-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/repository-5t3nmthw.js

@@ -0,0 +1,32 @@
+import {
+  WebSocketConstructor2
+} from "./repository-y8cydn3q.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/effect/app-node-platform.ts
+var exports_app_node_platform = {};
+__export(exports_app_node_platform, {
+  LayerNodePlatform: () => exports_app_node_platform,
+  llmClient: () => llmClient2,
+  requestExecutor: () => requestExecutor2,
+  webSocketConstructor: () => webSocketConstructor2
+});
+import { LLMClient, RequestExecutor } from "@opencode/ai/route";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+var requestExecutor2 = makeGlobalNode({
+  service: RequestExecutor.Service,
+  layer: RequestExecutor.layer,
+  deps: [httpClient]
+});
+var llmClient2 = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor2] });
+var webSocketConstructor2 = makeGlobalNode({
+  service: Socket.WebSocketConstructor,
+  layer: WebSocketConstructor2.layer,
+  deps: []
+});
+
+export { requestExecutor2, llmClient2, webSocketConstructor2, exports_app_node_platform };

package/dist/chunks/repository-5y5h33xd.js

@@ -0,0 +1,80 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/websearch/tavily.ts
+var exports_tavily = {};
+__export(exports_tavily, {
+  Plugin: () => Plugin32,
+  WebSearchTavily: () => exports_tavily,
+  endpoint: () => endpoint3
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var endpoint3 = "https://api.tavily.com/search";
+var SearchRequest = Schema.Struct({
+  query: Schema.String,
+  search_depth: Schema.Literal("basic"),
+  chunks_per_source: Schema.Number,
+  max_results: Schema.Number
+});
+var SearchResponse = Schema.Struct({
+  results: Schema.Array(Schema.Struct({
+    title: Schema.String,
+    url: Schema.String,
+    content: Schema.String
+  }))
+});
+var Plugin32 = define({
+  id: "opencode.websearch.tavily",
+  effect: Effect.fn("WebSearchTavily.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((editor) => {
+      editor.update("tavily", (integration) => integration.name = "Tavily");
+      editor.method.update({
+        integrationID: "tavily",
+        method: { type: "key" }
+      });
+      editor.method.update({
+        integrationID: "tavily",
+        method: { type: "env", names: ["TAVILY_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
+        id: "tavily",
+        name: "Tavily",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("tavily");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const request = yield* HttpClientRequest.post(endpoint3).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders({
+            "User-Agent": useragent2(ctx.app),
+            "X-Client-Name": "opencode2",
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : { "X-Tavily-Access-Mode": "keyless" }
+          }), HttpClientRequest.schemaBodyJson(SearchRequest)({
+            query: input.query,
+            search_depth: "basic",
+            chunks_per_source: 3,
+            max_results: 8
+          }));
+          const response = yield* HttpClient.withScope(HttpClient.filterStatusOk(http)).execute(request).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(SearchResponse)), Effect.scoped, Effect.timeoutOrElse({
+            duration: Duration.seconds(25),
+            orElse: () => Effect.fail(new Error("Tavily web search request timed out"))
+          }));
+          return response.results.map((item) => ({
+            url: item.url,
+            title: item.title,
+            ...item.content ? { content: item.content } : {},
+            time: {}
+          }));
+        })
+      });
+    });
+  })
+});
+
+export { endpoint3, Plugin32, exports_tavily };

package/dist/chunks/repository-669tq793.js

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

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

@@ -0,0 +1,75 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+
+// src/database/path.ts
+import nodePath from "path";
+import { customType } from "drizzle-orm/sqlite-core";
+import { Schema } from "effect";
+function storagePath(input) {
+  if (process.platform !== "win32")
+    return input;
+  return input.replaceAll("\\", "/");
+}
+function isWindowsStoragePath(input) {
+  return /^[A-Za-z]:\//.test(input) || input.startsWith("//");
+}
+function absolute(input) {
+  const result = storagePath(input);
+  if (!nodePath.posix.isAbsolute(result) && !isWindowsStoragePath(result)) {
+    throw new Error(`Path is not absolute: ${input}`);
+  }
+  return result;
+}
+function toPlatform(input) {
+  if (process.platform !== "win32" || !isWindowsStoragePath(input))
+    return input;
+  return input.replaceAll("/", "\\");
+}
+var absoluteColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return absolute(input);
+  },
+  fromDriver(input) {
+    return AbsolutePath2.make(toPlatform(absolute(input)));
+  }
+});
+var directoryColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return input ? absolute(input) : input;
+  },
+  fromDriver(input) {
+    return input ? toPlatform(absolute(input)) : input;
+  }
+});
+var pathColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return storagePath(input);
+  },
+  fromDriver(input) {
+    return storagePath(input);
+  }
+});
+var decodeAbsoluteArray = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(Schema.String)));
+var absoluteArrayColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return JSON.stringify(input.map(absolute));
+  },
+  fromDriver(input) {
+    return decodeAbsoluteArray(input).map((item) => AbsolutePath2.make(toPlatform(absolute(item))));
+  }
+});
+
+export { absoluteColumn2, directoryColumn2, pathColumn2, absoluteArrayColumn2 };

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

@@ -0,0 +1,16 @@
+// src/tool/plugin/file-diff.ts
+import { createTwoFilesPatch, diffLines } from "diff";
+function fileDiff2(file, before, after, status = "modified") {
+  const counts = diffLines(before, after).reduce((result, item) => ({
+    additions: result.additions + (item.added ? item.count ?? 0 : 0),
+    deletions: result.deletions + (item.removed ? item.count ?? 0 : 0)
+  }), { additions: 0, deletions: 0 });
+  return {
+    file,
+    patch: createTwoFilesPatch(file, file, before, after),
+    status,
+    ...counts
+  };
+}
+
+export { fileDiff2 };