@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-t0fxg8b9.js

@@ -0,0 +1,34 @@
+import {
+  PositiveInt2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/attachment.ts
+var exports_attachment = {};
+__export(exports_attachment, {
+  ConfigAttachmentV1: () => exports_attachment,
+  Image: () => Image2,
+  Info: () => Info12
+});
+import { Schema } from "effect";
+var Image2 = Schema.Struct({
+  auto_resize: Schema.optional(Schema.Boolean).annotate({
+    description: "Resize images before sending them to the model when they exceed configured limits (default: true)"
+  }),
+  max_width: Schema.optional(PositiveInt2).annotate({
+    description: "Maximum image width before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_height: Schema.optional(PositiveInt2).annotate({
+    description: "Maximum image height before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_base64_bytes: Schema.optional(PositiveInt2).annotate({
+    description: "Maximum base64 payload bytes for an image attachment (default: 5242880)"
+  })
+}).annotate({ identifier: "ImageAttachmentConfig" });
+var Info12 = Schema.Struct({
+  image: Schema.optional(Image2).annotate({ description: "Image attachment configuration" })
+}).annotate({ identifier: "AttachmentConfig" });
+
+export { Image2, Info12, exports_attachment };

package/dist/chunks/aisdk-native-t0x5rdq8.js

@@ -0,0 +1,53 @@
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/filesystem/location-watcher-policy.ts
+var exports_location_watcher_policy = {};
+__export(exports_location_watcher_policy, {
+  LocationWatcherPolicy: () => exports_location_watcher_policy,
+  Service: () => Service12,
+  node: () => node15
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Scope } from "effect";
+class Service12 extends Context.Service()("@opencode/LocationWatcherPolicy") {
+}
+var layer = Layer.effect(Service12, Effect.gen(function* () {
+  const listeners = new Set;
+  const state = create3({
+    name: "location-watcher-policy",
+    initial: () => ({ ignore: [] }),
+    editor: (editor) => ({
+      add: (ignore) => editor.ignore.push(...ignore),
+      list: () => editor.ignore
+    }),
+    notify: () => Effect.forEach(listeners, (listener) => listener(current()), { discard: true })
+  });
+  const current = () => state.get().ignore;
+  const observe = Effect.fn("LocationWatcherPolicy.observe")(function* (listener) {
+    const scope = yield* Scope.Scope;
+    let active = true;
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      listeners.delete(listener);
+    });
+    listeners.add(listener);
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  return Service12.of({
+    transform: state.transform,
+    reload: state.reload,
+    current,
+    observe
+  });
+}));
+var node15 = makeLocationNode({ service: Service12, layer, deps: [] });
+
+export { Service12, node15, exports_location_watcher_policy };

package/dist/chunks/aisdk-native-tazgh4e4.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/vcs/patch.ts
+var exports_patch2 = {};
+__export(exports_patch2, {
+  MAX_PATCH_BYTES: () => MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES: () => MAX_TOTAL_PATCH_BYTES2,
+  PATCH_CONTEXT_LINES: () => PATCH_CONTEXT_LINES2,
+  VcsPatch: () => exports_patch2,
+  addPatch: () => addPatch2,
+  chunksByFile: () => chunksByFile2,
+  countPatch: () => countPatch2,
+  deletePatch: () => deletePatch2,
+  emptyPatch: () => emptyPatch2,
+  fileFromPatchChunk: () => fileFromPatchChunk2,
+  splitGitPatch: () => splitGitPatch2
+});
+import { formatPatch, structuredPatch } from "diff";
+var PATCH_CONTEXT_LINES2 = 2147483647;
+var MAX_PATCH_BYTES2 = 1e7;
+var MAX_TOTAL_PATCH_BYTES2 = 1e7;
+var emptyPatch2 = (file) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }));
+var addPatch2 = (file, content) => formatPatch(structuredPatch(file, file, "", content, "", "", { context: 0 }));
+var deletePatch2 = (file, content) => formatPatch(structuredPatch(file, file, content, "", "", "", { context: 0 }));
+var countPatch2 = (patch) => {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      additions++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      deletions++;
+  }
+  return { additions, deletions };
+};
+var parseQuotedPath = (value) => {
+  let out = "";
+  for (let idx = 1;idx < value.length; idx++) {
+    const char = value[idx];
+    if (char === '"')
+      return { value: out, end: idx + 1 };
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = value[++idx];
+    if (next === "t")
+      out += "\t";
+    else if (next === "n")
+      out += `
+`;
+    else if (next === "r")
+      out += "\r";
+    else if (next === '"' || next === "\\")
+      out += next;
+    else
+      out += next ?? "";
+  }
+};
+var parsePathToken = (value) => {
+  if (!value.startsWith('"'))
+    return value.split("\t")[0];
+  return parseQuotedPath(value)?.value ?? value;
+};
+var fileFromDiffPath = (value) => {
+  if (!value || value === "/dev/null")
+    return;
+  const file = parsePathToken(value);
+  if (file.startsWith("a/") || file.startsWith("b/"))
+    return file.slice(2);
+  return file;
+};
+var fileFromGitHeader = (header) => {
+  if (header.startsWith('"')) {
+    const first = parseQuotedPath(header);
+    const second = first ? header.slice(first.end).trimStart() : undefined;
+    if (!second)
+      return;
+    if (!second.startsWith('"'))
+      return fileFromDiffPath(second);
+    return fileFromDiffPath(parseQuotedPath(second)?.value);
+  }
+  const separator = header.indexOf(" b/");
+  if (separator === -1)
+    return;
+  return fileFromDiffPath(header.slice(separator + 1));
+};
+var fileFromPatchChunk2 = (chunk) => {
+  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1];
+  const before = /^--- (.+)$/m.exec(chunk)?.[1];
+  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before);
+  if (file)
+    return file;
+  const header = /^diff --git (.+)$/m.exec(chunk)?.[1];
+  return fileFromGitHeader(header ?? "");
+};
+var splitGitPatch2 = (patch) => {
+  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) => match[0].startsWith(`
+`) ? match.index + 1 : match.index);
+  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length));
+  if (!patch.truncated)
+    return chunks;
+  return chunks.slice(0, -1);
+};
+var chunksByFile2 = (patch, fallback) => splitGitPatch2(patch).reduce((acc, chunk, index) => {
+  const file = fileFromPatchChunk2(chunk) ?? fallback(index);
+  if (!file)
+    return acc;
+  acc.set(file, (acc.get(file) ?? "") + chunk);
+  return acc;
+}, new Map);
+
+export { PATCH_CONTEXT_LINES2, MAX_PATCH_BYTES2, MAX_TOTAL_PATCH_BYTES2, emptyPatch2, addPatch2, deletePatch2, countPatch2, fileFromPatchChunk2, splitGitPatch2, chunksByFile2, exports_patch2 };

package/dist/chunks/aisdk-native-tcezcvh9.js

@@ -0,0 +1,63 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/filesystem/protected.ts
+var exports_protected = {};
+__export(exports_protected, {
+  Protected: () => exports_protected,
+  isHome: () => isHome2,
+  names: () => names3,
+  paths: () => paths2
+});
+import os from "os";
+import path from "path";
+var home = os.homedir();
+function isHome2(directory) {
+  return path.resolve(directory) === path.resolve(home);
+}
+var DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "Public",
+  "Applications",
+  "Library"
+];
+var DARWIN_LIBRARY = [
+  "Application Support/AddressBook",
+  "Calendars",
+  "Mail",
+  "Messages",
+  "Safari",
+  "Cookies",
+  "Application Support/com.apple.TCC",
+  "PersonalizationPortrait",
+  "Metadata/CoreSpotlight",
+  "Suggestions"
+];
+var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
+var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
+function names3() {
+  if (process.platform === "darwin")
+    return new Set(DARWIN_HOME);
+  if (process.platform === "win32")
+    return new Set(WIN32_HOME);
+  return new Set;
+}
+function paths2() {
+  if (process.platform === "darwin")
+    return [
+      ...DARWIN_HOME.map((name) => path.join(home, name)),
+      ...DARWIN_LIBRARY.map((name) => path.join(home, "Library", name)),
+      ...DARWIN_ROOT
+    ];
+  if (process.platform === "win32")
+    return WIN32_HOME.map((name) => path.join(home, name));
+  return [];
+}
+
+export { isHome2, names3, paths2, exports_protected };

package/dist/chunks/aisdk-native-tdstcens.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  SessionUsage: () => exports_usage,
+  add: () => add2,
+  calculateCost: () => calculateCost2,
+  record: () => record2,
+  tokens: () => tokens2
+});
+import { Money } from "@opencode/schema/money";
+var finite = (value) => Number.isFinite(value) ? value : 0;
+var safe = (value) => Math.max(0, finite(value ?? 0));
+var tokens2 = (usage) => ({
+  input: safe(usage?.nonCachedInputTokens),
+  output: safe(usage?.visibleOutputTokens),
+  reasoning: safe(usage?.reasoningTokens),
+  cache: {
+    read: safe(usage?.cacheReadInputTokens),
+    write: safe(usage?.cacheWriteInputTokens)
+  }
+});
+function calculateCost2(costs, usage) {
+  const context = usage.input + usage.cache.read + usage.cache.write;
+  const tier = costs.filter((cost) => cost.tier?.type === "context" && context > cost.tier.size).toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0];
+  const cost = tier ?? costs.find((cost) => cost.tier === undefined);
+  if (!cost)
+    return Money.USD.zero;
+  return Money.USD.make((usage.input * finite(cost.input) + (usage.output + usage.reasoning) * finite(cost.output) + usage.cache.read * finite(cost.cache.read) + usage.cache.write * finite(cost.cache.write)) / 1e6);
+}
+var record2 = (usage, costs) => {
+  const normalized = tokens2(usage);
+  return { tokens: normalized, cost: calculateCost2(costs, normalized) };
+};
+var add2 = (a, b) => ({
+  cost: Money.USD.make(a.cost + b.cost),
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: {
+      read: a.tokens.cache.read + b.tokens.cache.read,
+      write: a.tokens.cache.write + b.tokens.cache.write
+    }
+  }
+});
+
+export { tokens2, calculateCost2, record2, add2, exports_usage };

package/dist/chunks/aisdk-native-th5km1p3.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  WorktreeDirectory: () => exports_directory,
+  canonical: () => canonical3
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError2 extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath2 }) {
+}
+var canonical3 = Effect.fnUntraced(function* (fs, input) {
+  const resolved = AbsolutePath2.make(yield* fs.resolve(input));
+  if (!(yield* fs.isDir(resolved)))
+    return yield* new DirectoryUnavailableError2({ directory: input });
+  return resolved;
+});
+
+export { DirectoryUnavailableError2, canonical3, exports_directory };

package/dist/chunks/aisdk-native-tmmjahvp.js

@@ -0,0 +1,97 @@
+import {
+  VariantUnavailableError3,
+  UnsupportedPackageError3,
+  ModelConfigurationError3,
+  ModelInitializationError3,
+  UnresolvedProviderVariablesError3,
+  UnsupportedCompactionError3,
+  Service64,
+  node68
+} from "./aisdk-native-gd0e60kd.js";
+import {
+  SessionSchema2
+} from "./aisdk-native-y6f0p4jw.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/runner/model.ts
+var exports_model = {};
+__export(exports_model, {
+  ModelConfigurationError: () => ModelConfigurationError2,
+  ModelInitializationError: () => ModelInitializationError2,
+  ModelNotSelectedError: () => ModelNotSelectedError2,
+  ModelUnavailableError: () => ModelUnavailableError2,
+  Service: () => Service41,
+  SessionRunnerModel: () => exports_model,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError2,
+  UnsupportedCompactionError: () => UnsupportedCompactionError2,
+  UnsupportedPackageError: () => UnsupportedPackageError2,
+  VariantUnavailableError: () => VariantUnavailableError2,
+  node: () => node44,
+  resolved: () => resolved2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { Context, Effect, Layer, Schema } from "effect";
+class ModelNotSelectedError2 extends Schema.TaggedError()("SessionRunnerModel.ModelNotSelectedError", { sessionID: SessionSchema2.ID }) {
+  get message() {
+    return `No model is available for session ${this.sessionID}`;
+  }
+}
+
+class ModelUnavailableError2 extends Schema.TaggedError()("SessionRunnerModel.ModelUnavailableError", { providerID: Provider.ID, modelID: Model.ID }) {
+  get message() {
+    if (this.providerID === "azure-cognitive-services")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`;
+    if (this.providerID === "google-vertex-anthropic")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use google-vertex/${this.modelID} instead.`;
+    return `Model unavailable: ${this.providerID}/${this.modelID}`;
+  }
+}
+var VariantUnavailableError2 = VariantUnavailableError3;
+var UnsupportedPackageError2 = UnsupportedPackageError3;
+var ModelConfigurationError2 = ModelConfigurationError3;
+var ModelInitializationError2 = ModelInitializationError3;
+var UnresolvedProviderVariablesError2 = UnresolvedProviderVariablesError3;
+var UnsupportedCompactionError2 = UnsupportedCompactionError3;
+
+class Service41 extends Context.Service()("@opencode/SessionRunnerModel") {
+}
+var resolved2 = (model, options) => ({
+  model,
+  ref: Model.Ref.make({
+    id: Model.ID.make(model.id),
+    providerID: Provider.ID.make(model.provider),
+    ...options.variant === undefined ? {} : { variant: options.variant }
+  }),
+  capabilities: options.capabilities,
+  cost: options.cost,
+  limit: options.limit,
+  compaction: options.compaction,
+  websocket: options.websocket ?? false
+});
+var layer = Layer.effect(Service41, Effect.gen(function* () {
+  const resolver = yield* Service64;
+  return Service41.of({
+    resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session, available) {
+      if (!session.model) {
+        const resolved = yield* resolver.resolve();
+        if (resolved)
+          return resolved;
+        return yield* new ModelNotSelectedError2({ sessionID: session.id });
+      }
+      const selected = (yield* available()).find((model) => model.providerID === session.model?.providerID && model.id === session.model.id);
+      if (!selected)
+        return yield* new ModelUnavailableError2({
+          providerID: session.model.providerID,
+          modelID: session.model.id
+        });
+      return yield* resolver.resolveModel(selected, session.model.variant);
+    })
+  });
+}));
+var node44 = makeLocationNode({ service: Service41, layer, deps: [node68] });
+
+export { ModelNotSelectedError2, ModelUnavailableError2, VariantUnavailableError2, UnsupportedPackageError2, ModelConfigurationError2, ModelInitializationError2, UnresolvedProviderVariablesError2, UnsupportedCompactionError2, Service41, resolved2, node44, exports_model };