@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-3qdzwhqx.js

@@ -0,0 +1,184 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service35,
+  node38
+} from "./worktree-vkez6a4k.js";
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service75,
+  node80
+} from "./worktree-a8mtf1n7.js";
+import {
+  Ref4
+} from "./worktree-z82wee6n.js";
+import {
+  Service38,
+  node41
+} from "./worktree-w2jjwenf.js";
+import {
+  SessionMessage2
+} from "./worktree-gftt206x.js";
+import {
+  NotFoundError9
+} from "./worktree-k7d0894y.js";
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  Service33
+} from "./worktree-ca7w653e.js";
+import {
+  Service72,
+  node77
+} from "./worktree-3bgy0jaw.js";
+import {
+  Item2,
+  serialized2,
+  Service34,
+  node37,
+  moveIDs2
+} from "./worktree-vece14gy.js";
+import {
+  Service32,
+  node36
+} from "./worktree-d3p6gjbn.js";
+import {
+  node23
+} from "./worktree-s4cjsff2.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/move.ts
+var exports_move = {};
+__export(exports_move, {
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  Service: () => Service18,
+  SessionMove: () => exports_move,
+  node: () => node22
+});
+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 Service18 extends Context.Service()("@opencode/SessionMove") {
+}
+var layer = Layer.effect(Service18, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const projects = yield* Service75;
+  const locations = yield* Service38;
+  const store = yield* Service72;
+  const execution = yield* Service32;
+  const instances = yield* Service35;
+  const admission = yield* Service34;
+  const database = yield* Service80;
+  const bus = yield* Service79;
+  const get = Effect.fn("SessionMove.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError9({ 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: Ref4.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* Service33.pipe(instances.provide(session), Effect.as(false), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.succeed(true)));
+  });
+  return Service18.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 node22 = makeGlobalNode({
+  service: Service18,
+  layer,
+  deps: [
+    FSUtil.node,
+    Global.node,
+    node80,
+    node41,
+    node77,
+    node36,
+    node38,
+    node37,
+    node85,
+    node84,
+    node23
+  ]
+});
+
+export { DestinationNotFoundError2, DestinationNotDirectoryError2, DestinationUnavailableError2, Service18, node22, exports_move };

package/dist/chunks/worktree-3smtnn6g.js

@@ -0,0 +1,45 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/mime.ts
+var exports_mime = {};
+__export(exports_mime, {
+  Mime: () => exports_mime,
+  detect: () => detect2
+});
+function detect2(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10]))
+    return "image/png";
+  if (startsWith(bytes, [255, 216, 255]))
+    return "image/jpeg";
+  if (startsWith(bytes, [71, 73, 70, 56]))
+    return "image/gif";
+  if (startsWith(bytes, [66, 77]))
+    return "image/bmp";
+  if (startsWith(bytes, [37, 80, 68, 70, 45]))
+    return "application/pdf";
+  if (startsWith(bytes, [82, 73, 70, 70]) && startsWith(bytes.subarray(8), [87, 69, 66, 80]))
+    return "image/webp";
+  if (startsWith(bytes.subarray(4), [102, 116, 121, 112]) && (startsWith(bytes.subarray(8), [97, 118, 105, 102]) || startsWith(bytes.subarray(8), [97, 118, 105, 115])))
+    return "image/avif";
+  return isText(bytes) ? "text/plain" : "application/octet-stream";
+}
+function startsWith(bytes, prefix) {
+  return prefix.every((value, index) => bytes[index] === value);
+}
+function isText(bytes) {
+  if (bytes.length === 0)
+    return true;
+  if (bytes.includes(0))
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+  } catch {
+    return false;
+  }
+  const controls = bytes.reduce((count, byte) => count + Number(byte < 9 || byte > 13 && byte < 32), 0);
+  return controls / bytes.length <= 0.3;
+}
+
+export { detect2, exports_mime };

package/dist/chunks/worktree-3tvqynh2.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/database/v1-migration.ts
+var exports_v1_migration = {};
+__export(exports_v1_migration, {
+  V1Migration: () => V1Migration2
+});
+import * as V1Migration2 from "#v1-migration";
+
+export * from "#v1-migration";
+
+export { exports_v1_migration, V1Migration2 };

package/dist/chunks/worktree-3v8g72cx.js

@@ -0,0 +1,28 @@
+// src/tool/http-body.ts
+import { Effect, Stream } from "effect";
+var collectBoundedResponseBody2 = (response, maximumBytes, tooLarge) => Effect.gen(function* () {
+  const contentLength = response.headers["content-length"];
+  const parsedSize = contentLength ? Number.parseInt(contentLength, 10) : undefined;
+  const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined;
+  if (declaredSize !== undefined && declaredSize > maximumBytes)
+    return yield* Effect.fail(tooLarge());
+  let body = Buffer.allocUnsafe(Math.min(maximumBytes, declaredSize || 64 * 1024));
+  let size = 0;
+  yield* Stream.runForEach(response.stream, (chunk) => {
+    if (chunk.byteLength === 0)
+      return Effect.void;
+    if (size + chunk.byteLength > maximumBytes)
+      return Effect.fail(tooLarge());
+    if (size + chunk.byteLength > body.byteLength) {
+      const grown = Buffer.allocUnsafe(Math.min(maximumBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)));
+      body.copy(grown, 0, 0, size);
+      body = grown;
+    }
+    body.set(chunk, size);
+    size += chunk.byteLength;
+    return Effect.void;
+  });
+  return body.subarray(0, size);
+});
+
+export { collectBoundedResponseBody2 };

package/dist/chunks/worktree-3w5fmr99.js

@@ -0,0 +1,214 @@
+// src/tool/runtime.ts
+import { Tool } from "@opencode/schema/tool";
+import { Cache, Effect, JsonSchema, Schema, SchemaIssue, SchemaRepresentation } from "effect";
+import { $ZodType, toJSONSchema } from "zod/v4/core";
+var formatEffectIssues = SchemaIssue.makeFormatterStandardSchemaV1();
+var jsonSchemas = Effect.runSync(Cache.make({
+  capacity: 100,
+  lookup: (schema) => Effect.try({
+    try: () => jsonSchema(schema),
+    catch: () => {
+      return;
+    }
+  }).pipe(Effect.orElseSucceed(() => {
+    return;
+  }))
+}));
+var definition2 = (tool) => ({
+  type: "tool",
+  name: effectiveName2(tool),
+  description: tool.description,
+  inputSchema: inputJsonSchema(tool.input),
+  ...tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }
+});
+var execute3 = (tool, input, context) => Effect.gen(function* () {
+  const decoded = yield* decodeInput(tool, input);
+  const result = yield* tool.execute(decoded, context).pipe(Effect.mapError((error) => error instanceof Tool.Error ? error : new Tool.Error({
+    message: error instanceof globalThis.Error ? error.message : String(error)
+  })));
+  if (tool.output === undefined) {
+    if ("output" in result)
+      return yield* Effect.die("Tool result declared output without an output schema");
+    return {
+      output: undefined,
+      content: normalizeContent2(result.content),
+      ...result.metadata === undefined ? {} : { metadata: result.metadata }
+    };
+  }
+  if (!("output" in result))
+    return yield* new Tool.Error({ message: "Tool did not return its declared output" });
+  const output = yield* encodeOutput(tool.output, result.output);
+  return {
+    output,
+    content: normalizeContent2(result.content, output),
+    ...result.metadata === undefined ? {} : { metadata: result.metadata }
+  };
+});
+var decodeInput = (tool, value) => Effect.gen(function* () {
+  const result = yield* validateInput(tool.input, value);
+  if (result.issues)
+    return yield* new Tool.Error({ message: formatInputIssues(effectiveName2(tool), result.issues, value) });
+  return result.value;
+});
+var validateInput = (schema, value) => {
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value);
+  return Effect.gen(function* () {
+    const codec = Schema.isSchema(schema) ? schema : yield* Cache.get(jsonSchemas, schema);
+    if (codec === undefined)
+      return { value };
+    return yield* Schema.decodeUnknownEffect(codec)(value, { errors: "all" }).pipe(Effect.match({
+      onFailure: (error) => formatEffectIssues(error.issue),
+      onSuccess: (value) => ({ value })
+    }));
+  });
+};
+var formatInputIssues = (tool, issues, value) => {
+  const details = issues.slice(0, 5).map((issue) => {
+    const path = issue.path?.reduce((path, segment) => {
+      const key = typeof segment === "object" ? segment.key : segment;
+      if (typeof key === "number")
+        return `${path}[${key}]`;
+      return path === "" ? String(key) : `${path}.${String(key)}`;
+    }, "") || "root";
+    return `- ${path}: ${issue.message}`;
+  });
+  if (issues.length > 5)
+    details.push(`- ...and ${issues.length - 5} more ${issues.length === 6 ? "issue" : "issues"}`);
+  return `Invalid arguments for tool "${tool}":
+${details.join(`
+`)}
+
+Arguments provided:
+${JSON.stringify(value, null, 2)}
+
+Update the arguments and call the tool again.`;
+};
+var jsonSchema = (schema) => {
+  const draft = typeof schema.$schema === "string" && schema.$schema.includes("draft-07") || "definitions" in schema ? JsonSchema.fromSchemaDraft07(schema) : JsonSchema.fromSchemaDraft2020_12(schema);
+  return Schema.make(SchemaRepresentation.fromJsonSchemaDocument(draft).ast);
+};
+var encodeOutput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value).pipe(Effect.flatMap((result) => result.issues ? new Tool.Error({
+      message: `Tool returned an invalid value for its output schema: ${result.issues.map((issue) => issue.message).join(", ")}`
+    }) : Effect.succeed(result.value)));
+  return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
+};
+var isStandardSchema = (schema) => typeof schema === "object" && schema !== null && ("~standard" in schema);
+var isStandardJSONSchema = (schema) => ("jsonSchema" in schema["~standard"]);
+var validateStandard = (schema, value) => Effect.gen(function* () {
+  const result = yield* Effect.try({ try: () => schema["~standard"].validate(value), catch: (error) => error });
+  return result instanceof Promise ? yield* Effect.tryPromise({ try: () => result, catch: (error) => error }) : result;
+}).pipe(Effect.match({
+  onFailure: (error) => ({ issues: [{ message: error instanceof Error ? error.message : String(error) }] }),
+  onSuccess: (result) => result
+}));
+var inputJsonSchema = (schema) => {
+  if (schema === undefined || schema === null)
+    return {};
+  if (isStandardSchema(schema))
+    return standardJsonSchema(schema, "input");
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var outputJsonSchema = (schema) => {
+  if (isStandardSchema(schema))
+    return standardJsonSchema(schema, "output");
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var standardJsonSchema = (schema, io) => {
+  if (isStandardJSONSchema(schema))
+    return schema["~standard"].jsonSchema[io]({ target: "draft-2020-12" });
+  if (schema instanceof $ZodType)
+    return toJSONSchema(schema, { target: "draft-2020-12", io });
+  throw new Error(`Schema vendor "${schema["~standard"].vendor}" does not support JSON Schema conversion`);
+};
+var toJsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema);
+  const normalized = flattenAllOf(Object.keys(document.definitions).length === 0 ? document.schema : { ...document.schema, $defs: document.definitions });
+  return dropDefinitionsIfResolved(inlineLocalReferences(normalized));
+};
+var flattenAllOf = (value) => {
+  if (Array.isArray(value))
+    return value.map(flattenAllOf);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+  if (!Array.isArray(schema.allOf) || !schema.allOf.every(isRecord) || !canFlattenAllOf(schema.allOf, schema))
+    return schema;
+  const { allOf, ...rest } = schema;
+  return flattenAllOf({ ...Object.assign({}, ...allOf), ...rest });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canFlattenAllOf = (allOf, parent) => {
+  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"));
+  return allOf.every((item) => Object.keys(item).every((key) => {
+    if (keys.has(key))
+      return false;
+    keys.add(key);
+    return true;
+  }));
+};
+var inlineLocalReferences = (value, definitions, seen = new Set) => {
+  if (Array.isArray(value))
+    return value.map((item) => inlineLocalReferences(item, definitions, seen));
+  if (!isRecord(value))
+    return value;
+  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined);
+  if (typeof value.$ref === "string" && localDefinitions) {
+    const segment = value.$ref.match(/^#\/\$defs\/([^/]+)$/)?.[1];
+    const name = segment?.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (name && !seen.has(name)) {
+      const target = localDefinitions[name];
+      if (target) {
+        const { $ref: _, ...rest } = value;
+        const resolvedTarget = inlineLocalReferences(target, localDefinitions, new Set(seen).add(name));
+        const resolvedSiblings = inlineLocalReferences(rest, localDefinitions, seen);
+        if (!isRecord(resolvedTarget) || !isRecord(resolvedSiblings))
+          return resolvedTarget;
+        if (canMergeRecords(resolvedTarget, resolvedSiblings))
+          return { ...resolvedTarget, ...resolvedSiblings };
+        return { allOf: [resolvedTarget, resolvedSiblings] };
+      }
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]));
+};
+var canMergeRecords = (left, right) => Object.keys(left).every((key) => !(key in right));
+var dropDefinitionsIfResolved = (value) => {
+  if (!isRecord(value) || hasLocalReference(value))
+    return value;
+  const { $defs: _, ...rest } = value;
+  return rest;
+};
+var hasLocalReference = (value) => {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#/$defs/"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+};
+var normalizeContent2 = (value, output) => {
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  if (value !== undefined && value.length > 0)
+    return [...value];
+  return [{ type: "text", text: stringify(output) }];
+};
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var normalizedName2 = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName2 = (tool) => tool.options?.namespace === undefined ? normalizedName2(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName2(tool)}`;
+
+export { definition2, execute3, normalizeContent2, normalizedName2, effectiveName2 };

package/dist/chunks/worktree-3wcehsnq.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/web-search.ts
+import { z } from "zod/v4";
+var webSearchArgsSchema2 = z.object({
+  filters: z.object({
+    allowedDomains: z.array(z.string()).optional()
+  }).optional(),
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+  userLocation: z.object({
+    type: z.literal("approximate"),
+    country: z.string().optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    timezone: z.string().optional()
+  }).optional()
+});
+
+export { webSearchArgsSchema2 };