@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-vz89hfgr.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/vcs/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  splitGitPatch: () => splitGitPatch,
+  fileFromPatchChunk: () => fileFromPatchChunk,
+  emptyPatch: () => emptyPatch,
+  deletePatch: () => deletePatch,
+  countPatch: () => countPatch,
+  chunksByFile: () => chunksByFile,
+  addPatch: () => addPatch,
+  VcsPatch: () => exports_patch,
+  PATCH_CONTEXT_LINES: () => PATCH_CONTEXT_LINES,
+  MAX_TOTAL_PATCH_BYTES: () => MAX_TOTAL_PATCH_BYTES,
+  MAX_PATCH_BYTES: () => MAX_PATCH_BYTES
+});
+import { formatPatch, structuredPatch } from "diff";
+var PATCH_CONTEXT_LINES = 2147483647;
+var MAX_PATCH_BYTES = 1e7;
+var MAX_TOTAL_PATCH_BYTES = 1e7;
+var emptyPatch = (file) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }));
+var addPatch = (file, content) => formatPatch(structuredPatch(file, file, "", content, "", "", { context: 0 }));
+var deletePatch = (file, content) => formatPatch(structuredPatch(file, file, content, "", "", "", { context: 0 }));
+var countPatch = (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 fileFromPatchChunk = (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 splitGitPatch = (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 chunksByFile = (patch, fallback) => splitGitPatch(patch).reduce((acc, chunk, index) => {
+  const file = fileFromPatchChunk(chunk) ?? fallback(index);
+  if (!file)
+    return acc;
+  acc.set(file, (acc.get(file) ?? "") + chunk);
+  return acc;
+}, new Map);
+
+export { PATCH_CONTEXT_LINES, MAX_PATCH_BYTES, MAX_TOTAL_PATCH_BYTES, emptyPatch, addPatch, deletePatch, countPatch, fileFromPatchChunk, splitGitPatch, chunksByFile, exports_patch };

package/dist/chunks/location-mutation-w35hs5me.js

@@ -0,0 +1,12 @@
+import {
+  migrate
+} from "./location-mutation-9314w1nf.js";
+
+// src/database/drizzle/effect-sqlite/migrator.ts
+import { readMigrationFiles } from "drizzle-orm/migrator";
+function migrate2(db, config) {
+  const migrations = readMigrationFiles(config);
+  return migrate(migrations, db.session, config);
+}
+
+export { migrate2 as migrate };

package/dist/chunks/location-mutation-w6yb7hdq.js

@@ -0,0 +1,322 @@
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/form.ts
+var exports_form = {};
+__export(exports_form, {
+  validateFields: () => validateFields,
+  validateAnswer: () => validateAnswer,
+  node: () => node,
+  layer: () => layer,
+  When: () => When,
+  State: () => State,
+  Service: () => Service,
+  Reply: () => Reply,
+  NotFoundError: () => NotFoundError,
+  InvalidFormError: () => InvalidFormError,
+  InvalidAnswerError: () => InvalidAnswerError,
+  Info: () => Info,
+  ID: () => ID,
+  Form: () => exports_form,
+  Fields: () => Fields,
+  Field: () => Field,
+  Event: () => Event,
+  Answer: () => Answer,
+  AlreadySettledError: () => AlreadySettledError,
+  AlreadyExistsError: () => AlreadyExistsError
+});
+import { Form } from "@opencode-ai/schema/form";
+import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Event } from "@opencode-ai/schema/form";
+var RETENTION = Duration.minutes(10);
+var ID = Form.ID;
+var Info = Form.Info;
+var Field = Form.Field;
+var Fields = Form.Fields;
+var When = Form.When;
+var State = Form.State;
+var Answer = Form.Answer;
+var Reply = Form.Reply;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Form.NotFoundError", {
+  id: ID
+}) {
+  get message() {
+    return `Form not found: ${this.id}`;
+  }
+}
+
+class AlreadySettledError extends Schema.TaggedErrorClass()("Form.AlreadySettledError", {
+  id: ID
+}) {
+  get message() {
+    return `Form already settled: ${this.id}`;
+  }
+}
+
+class AlreadyExistsError extends Schema.TaggedErrorClass()("Form.AlreadyExistsError", {
+  id: ID
+}) {
+  get message() {
+    return `Form already exists: ${this.id}`;
+  }
+}
+
+class InvalidAnswerError extends Schema.TaggedErrorClass()("Form.InvalidAnswerError", {
+  id: ID,
+  message: Schema.String
+}) {
+}
+
+class InvalidFormError extends Schema.TaggedErrorClass()("Form.InvalidFormError", {
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Form") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
+    capacity: Number.MAX_SAFE_INTEGER,
+    timeToLive: (exit) => Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION
+  });
+  const find = Effect.fn("Form.find")(function* (id) {
+    return yield* Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Option.match(entry, {
+      onNone: () => Effect.fail(new NotFoundError({ id })),
+      onSome: Effect.succeed
+    })));
+  });
+  const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const id = input.id ?? ID.create();
+    const existing = yield* Cache.getSuccess(forms, id);
+    if (Option.isSome(existing))
+      return yield* new AlreadyExistsError({ id });
+    const invalid = validateFields(input.fields);
+    if (invalid)
+      return yield* new InvalidFormError({ message: invalid });
+    const form = {
+      id,
+      sessionID: input.sessionID,
+      title: input.title,
+      ...input.metadata === undefined ? {} : { metadata: input.metadata },
+      fields: input.fields
+    };
+    const entry = {
+      form,
+      state: { status: "pending" },
+      deferred: yield* Deferred.make()
+    };
+    yield* Cache.set(forms, id, entry);
+    yield* bus.publish(Form.Event.Created, { form }).pipe(Effect.onError(() => Cache.invalidate(forms, id)));
+    return form;
+  })));
+  const ask = Effect.fn("Form.ask")((input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const form = yield* create(input);
+    const entry = yield* find(form.id).pipe(Effect.orDie);
+    return yield* restore(Deferred.await(entry.deferred)).pipe(Effect.onInterrupt(() => Effect.ignore(cancel(form.id))));
+  })));
+  const get = Effect.fn("Form.get")(function* (id) {
+    return (yield* find(id)).form;
+  });
+  const list = Effect.fn("Form.list")(function* (input) {
+    const entries = yield* Cache.values(forms);
+    return Array.from(entries).filter((entry) => entry.state.status === "pending").filter((entry) => input?.sessionID === undefined || entry.form.sessionID === input.sessionID).map((entry) => entry.form);
+  });
+  const state = Effect.fn("Form.state")(function* (id) {
+    return (yield* find(id)).state;
+  });
+  const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* find(input.id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError({ id: input.id });
+    const invalid = validateAnswer(entry.form.fields, input.answer);
+    if (invalid)
+      return yield* new InvalidAnswerError({ id: input.id, message: invalid });
+    const next = { status: "answered", answer: input.answer };
+    yield* bus.publish(Form.Event.Replied, {
+      id: input.id,
+      sessionID: entry.form.sessionID,
+      answer: input.answer
+    });
+    yield* Cache.set(forms, input.id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  const cancel = Effect.fn("Form.cancel")((id) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* find(id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError({ id });
+    const next = { status: "cancelled" };
+    yield* bus.publish(Form.Event.Cancelled, { id, sessionID: entry.form.sessionID });
+    yield* Cache.set(forms, id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  yield* Effect.addFinalizer(() => Cache.values(forms).pipe(Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true }))));
+  return Service.of({ create, ask, get, list, state, reply, cancel });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node] });
+function validateAnswer(form, answer) {
+  const fields = new Map(form.map((field) => [field.key, field]));
+  for (const key of Object.keys(answer)) {
+    if (!fields.has(key))
+      return `Unknown form field: ${key}`;
+  }
+  for (const field of form) {
+    const value = answer[field.key];
+    if (field.type === "external") {
+      if (value !== true)
+        return `External form field must be acknowledged: ${field.key}`;
+      continue;
+    }
+    const active = isActive(field, answer);
+    if (value === undefined) {
+      if (field.required && active)
+        return `Missing required form field: ${field.key}`;
+      continue;
+    }
+    if (!active)
+      return `Form field is not active: ${field.key}`;
+    const invalid = validateField(field, value);
+    if (invalid)
+      return invalid;
+  }
+}
+function isActive(field, answer) {
+  if (!field.when)
+    return true;
+  return field.when.every((when) => matches(when, answer[when.key]));
+}
+function matches(when, value) {
+  if (value === undefined)
+    return false;
+  const hit = Array.isArray(value) ? value.some((item) => item === when.value) : value === when.value;
+  return when.op === "eq" ? hit : !hit;
+}
+function validateFields(fields) {
+  if (fields.length === 0)
+    return "Form must have at least one field";
+  const earlier = new Map;
+  const keys = new Set;
+  for (const field of fields) {
+    if (keys.has(field.key))
+      return `Duplicate form field key: ${field.key}`;
+    keys.add(field.key);
+    if (field.type === "external")
+      continue;
+    for (const when of field.when ?? []) {
+      const target = earlier.get(when.key);
+      if (!target)
+        return `Form field condition must reference an earlier field: ${field.key} -> ${when.key}`;
+      const invalid = validateWhen(when, target);
+      if (invalid)
+        return `${invalid}: ${field.key} -> ${when.key}`;
+    }
+    earlier.set(field.key, field);
+  }
+}
+function validateWhen(when, target) {
+  if (target.type === "boolean") {
+    if (typeof when.value !== "boolean")
+      return "Form field condition value must be a boolean";
+    return;
+  }
+  if (target.type === "number" || target.type === "integer") {
+    if (typeof when.value !== "number")
+      return "Form field condition value must be a number";
+    return;
+  }
+  if (typeof when.value !== "string")
+    return "Form field condition value must be a string";
+  const closed = target.type === "multiselect" ? !target.custom : target.options !== undefined && !target.custom;
+  if (closed && !target.options?.some((option) => option.value === when.value)) {
+    return "Form field condition value must be one of the field's options";
+  }
+}
+function validateField(field, value) {
+  if (field.type === "string") {
+    if (typeof value !== "string")
+      return `Expected string for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minLength !== undefined && value.length < field.minLength)
+      return `Form field is too short: ${field.key}`;
+    if (field.maxLength !== undefined && value.length > field.maxLength)
+      return `Form field is too long: ${field.key}`;
+    if (field.pattern !== undefined) {
+      try {
+        if (!new RegExp(field.pattern).test(value))
+          return `Form field does not match pattern: ${field.key}`;
+      } catch {
+        return `Form field has invalid pattern: ${field.key}`;
+      }
+    }
+    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+      return `Expected email for form field: ${field.key}`;
+    if (field.format === "uri" && !isUri(value))
+      return `Expected URI for form field: ${field.key}`;
+    if (field.format === "date" && !isDate(value))
+      return `Expected date for form field: ${field.key}`;
+    if (field.format === "date-time" && !isDateTime(value))
+      return `Expected date-time for form field: ${field.key}`;
+    if (field.options && !field.custom && !field.options.some((option) => option.value === value)) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+    return;
+  }
+  if (field.type === "number" || field.type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return `Expected number for form field: ${field.key}`;
+    if (field.type === "integer" && !Number.isInteger(value))
+      return `Expected integer for form field: ${field.key}`;
+    if (field.minimum !== undefined && value < field.minimum)
+      return `Form field is too small: ${field.key}`;
+    if (field.maximum !== undefined && value > field.maximum)
+      return `Form field is too large: ${field.key}`;
+    return;
+  }
+  if (field.type === "boolean") {
+    if (typeof value !== "boolean")
+      return `Expected boolean for form field: ${field.key}`;
+    return;
+  }
+  if (field.type === "multiselect") {
+    if (!isStringArray(value))
+      return `Expected string array for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minItems !== undefined && value.length < field.minItems)
+      return `Too few selections for form field: ${field.key}`;
+    if (field.maxItems !== undefined && value.length > field.maxItems)
+      return `Too many selections for form field: ${field.key}`;
+    if (!field.custom && value.some((item) => !field.options.some((option) => option.value === item))) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+  }
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isUri(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function isDateTime(value) {
+  return !Number.isNaN(new Date(value).getTime());
+}
+
+export { ID, Info, Field, Fields, When, State, Answer, Reply, NotFoundError, AlreadySettledError, AlreadyExistsError, InvalidAnswerError, InvalidFormError, Service, layer, node, validateAnswer, validateFields, exports_form, Event };