@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-706a4azd.js

@@ -0,0 +1,292 @@
+import {
+  which
+} from "./ripgrep-g7k9te92.js";
+
+// src/formatter/builtins.ts
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make(input) {
+  const disabled = false;
+  const findExecutable = (name) => which(name, undefined, input.bin);
+  const findUp = (target) => input.fs.findUp(target, input.directory, input.worktree);
+  const readText = (file) => input.fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""));
+  const commandOutput = (command) => input.processes.run(ChildProcess.make(command[0], command.slice(1), {
+    cwd: input.directory,
+    extendEnv: true,
+    stdin: "ignore"
+  })).pipe(Effect.option);
+  const gofmt = {
+    name: "gofmt",
+    extensions: [".go"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("gofmt");
+      return match ? [match, "-w", "$FILE"] : disabled;
+    })
+  };
+  const mix = {
+    name: "mix",
+    extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("mix");
+      return match ? [match, "format", "$FILE"] : disabled;
+    })
+  };
+  const prettier = {
+    name: "prettier",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".ts",
+      ".tsx",
+      ".mts",
+      ".cts",
+      ".html",
+      ".htm",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".vue",
+      ".svelte",
+      ".json",
+      ".jsonc",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".md",
+      ".mdx",
+      ".graphql",
+      ".gql"
+    ],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("package.json")) {
+        if (!hasDependency(yield* input.fs.readJson(file), "prettier"))
+          continue;
+        const bin = yield* input.npm.which("prettier");
+        if (bin)
+          return [bin, "--write", "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const oxfmt = {
+    name: "oxfmt",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("package.json")) {
+        if (!hasDependency(yield* input.fs.readJson(file), "oxfmt"))
+          continue;
+        const bin = yield* input.npm.which("oxfmt");
+        if (bin)
+          return [bin, "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const biome = {
+    name: "biome",
+    environment: { BUN_BE_BUN: "1" },
+    extensions: [
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".ts",
+      ".tsx",
+      ".mts",
+      ".cts",
+      ".html",
+      ".htm",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".vue",
+      ".svelte",
+      ".json",
+      ".jsonc",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".md",
+      ".mdx",
+      ".graphql",
+      ".gql"
+    ],
+    enabled: Effect.gen(function* () {
+      const found = yield* Effect.forEach(["biome.json", "biome.jsonc"], findUp, { concurrency: "unbounded" });
+      if (!found.some((items) => items.length > 0))
+        return disabled;
+      const bin = yield* input.npm.which("@biomejs/biome");
+      return bin ? [bin, "format", "--write", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const zig = {
+    name: "zig",
+    extensions: [".zig", ".zon"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("zig");
+      return match ? [match, "fmt", "$FILE"] : disabled;
+    })
+  };
+  const clang = {
+    name: "clang-format",
+    extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+    enabled: Effect.gen(function* () {
+      if (!(yield* findUp(".clang-format")).length)
+        return disabled;
+      const match = findExecutable("clang-format");
+      return match ? [match, "-i", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const ktlint = {
+    name: "ktlint",
+    extensions: [".kt", ".kts"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("ktlint");
+      return match ? [match, "-F", "$FILE"] : disabled;
+    })
+  };
+  const ruff = {
+    name: "ruff",
+    extensions: [".py", ".pyi"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("ruff");
+      if (!bin)
+        return disabled;
+      for (const config of ["pyproject.toml", "ruff.toml", ".ruff.toml"]) {
+        const found = yield* findUp(config);
+        if (!found.length)
+          continue;
+        if (config !== "pyproject.toml" || (yield* readText(found[0])).includes("[tool.ruff]")) {
+          return [bin, "format", "$FILE"];
+        }
+      }
+      for (const dependency of ["requirements.txt", "pyproject.toml", "Pipfile"]) {
+        const found = yield* findUp(dependency);
+        if (found.length && (yield* readText(found[0])).includes("ruff"))
+          return [bin, "format", "$FILE"];
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const air = {
+    name: "air",
+    extensions: [".R"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("air");
+      if (!bin)
+        return disabled;
+      const output = yield* commandOutput([bin, "--help"]);
+      if (output._tag === "None" || output.value.exitCode !== 0)
+        return disabled;
+      const first = output.value.stdout.toString("utf8").split(`
+`)[0];
+      return first.includes("R language") && first.includes("formatter") ? [bin, "format", "$FILE"] : disabled;
+    })
+  };
+  const uv = {
+    name: "uv",
+    extensions: [".py", ".pyi"],
+    enabled: Effect.gen(function* () {
+      const bin = findExecutable("uv");
+      if (!bin)
+        return disabled;
+      const output = yield* commandOutput([bin, "format", "--help"]);
+      return output._tag === "Some" && output.value.exitCode === 0 ? [bin, "format", "--", "$FILE"] : disabled;
+    })
+  };
+  const rubocop = executable("rubocop", [".rb", ".rake", ".gemspec", ".ru"], ["--autocorrect", "$FILE"], findExecutable);
+  const standardrb = executable("standardrb", [".rb", ".rake", ".gemspec", ".ru"], ["--fix", "$FILE"], findExecutable);
+  const htmlbeautifier = executable("htmlbeautifier", [".erb", ".html.erb"], ["$FILE"], findExecutable);
+  const dart = executable("dart", [".dart"], ["format", "$FILE"], findExecutable);
+  const ocamlformat = {
+    name: "ocamlformat",
+    extensions: [".ml", ".mli"],
+    enabled: Effect.gen(function* () {
+      if (!(yield* findUp(".ocamlformat")).length)
+        return disabled;
+      const match = findExecutable("ocamlformat");
+      return match ? [match, "-i", "$FILE"] : disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const terraform = executable("terraform", [".tf", ".tfvars"], ["fmt", "$FILE"], findExecutable);
+  const latexindent = executable("latexindent", [".tex"], ["-w", "-s", "$FILE"], findExecutable);
+  const gleam = executable("gleam", [".gleam"], ["format", "$FILE"], findExecutable);
+  const shfmt = executable("shfmt", [".sh", ".bash"], ["-w", "$FILE"], findExecutable);
+  const nixfmt = executable("nixfmt", [".nix"], ["$FILE"], findExecutable);
+  const rustfmt = executable("rustfmt", [".rs"], ["$FILE"], findExecutable);
+  const pint = {
+    name: "pint",
+    extensions: [".php"],
+    enabled: Effect.gen(function* () {
+      for (const file of yield* findUp("composer.json")) {
+        const json = yield* input.fs.readJson(file);
+        if (hasRecordKey(json, "require", "laravel/pint") || hasRecordKey(json, "require-dev", "laravel/pint")) {
+          return ["./vendor/bin/pint", "$FILE"];
+        }
+      }
+      return disabled;
+    }).pipe(Effect.orElseSucceed(() => disabled))
+  };
+  const ormolu = executable("ormolu", [".hs"], ["-i", "$FILE"], findExecutable);
+  const cljfmt = executable("cljfmt", [".clj", ".cljs", ".cljc", ".edn"], ["fix", "--quiet", "$FILE"], findExecutable);
+  const dfmt = executable("dfmt", [".d"], ["-i", "$FILE"], findExecutable);
+  return [
+    gofmt,
+    mix,
+    oxfmt,
+    prettier,
+    biome,
+    zig,
+    clang,
+    ktlint,
+    ruff,
+    air,
+    uv,
+    rubocop,
+    standardrb,
+    htmlbeautifier,
+    dart,
+    ocamlformat,
+    terraform,
+    latexindent,
+    gleam,
+    shfmt,
+    nixfmt,
+    rustfmt,
+    pint,
+    ormolu,
+    cljfmt,
+    dfmt
+  ];
+}
+function executable(name, extensions, args, findExecutable) {
+  return {
+    name,
+    extensions,
+    enabled: Effect.sync(() => {
+      const match = findExecutable(name);
+      return match ? [match, ...args] : false;
+    })
+  };
+}
+function hasDependency(input, dependency) {
+  return hasRecordKey(input, "dependencies", dependency) || hasRecordKey(input, "devDependencies", dependency);
+}
+function hasRecordKey(input, field, key) {
+  if (!isRecord(input))
+    return false;
+  return isRecord(input[field]) && key in input[field];
+}
+function isRecord(input) {
+  return Boolean(input && typeof input === "object" && !Array.isArray(input));
+}
+
+export { make };

package/dist/chunks/ripgrep-75tpgmct.js

@@ -0,0 +1,322 @@
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-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 };