@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-rjbw5qw4.js

@@ -0,0 +1,310 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/form.ts
+var exports_form = {};
+__export(exports_form, {
+  AlreadyExistsError: () => AlreadyExistsError2,
+  AlreadySettledError: () => AlreadySettledError2,
+  Answer: () => Answer2,
+  Event: () => Event15,
+  Field: () => Field2,
+  Fields: () => Fields2,
+  Form: () => exports_form,
+  ID: () => ID9,
+  Info: () => Info23,
+  InvalidAnswerError: () => InvalidAnswerError2,
+  InvalidFormError: () => InvalidFormError2,
+  NotFoundError: () => NotFoundError7,
+  Reply: () => Reply2,
+  Service: () => Service65,
+  State: () => State3,
+  When: () => When2,
+  layer: () => layer24,
+  node: () => node70,
+  validateAnswer: () => validateAnswer2,
+  validateFields: () => validateFields2
+});
+import { Form } from "@opencode/schema/form";
+import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Event as Event15 } from "@opencode/schema/form";
+var RETENTION = Duration.minutes(10);
+var ID9 = Form.ID;
+var Info23 = Form.Info;
+var Field2 = Form.Field;
+var Fields2 = Form.Fields;
+var When2 = Form.When;
+var State3 = Form.State;
+var Answer2 = Form.Answer;
+var Reply2 = Form.Reply;
+
+class NotFoundError7 extends Schema.TaggedError()("Form.NotFoundError", {
+  id: ID9
+}) {
+  get message() {
+    return `Form not found: ${this.id}`;
+  }
+}
+
+class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
+  id: ID9
+}) {
+  get message() {
+    return `Form already settled: ${this.id}`;
+  }
+}
+
+class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
+  id: ID9
+}) {
+  get message() {
+    return `Form already exists: ${this.id}`;
+  }
+}
+
+class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
+  id: ID9,
+  message: Schema.String
+}) {
+}
+
+class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
+  message: Schema.String
+}) {
+}
+
+class Service65 extends Context.Service()("@opencode/Form") {
+}
+var layer24 = Layer.effect(Service65, Effect.gen(function* () {
+  const bus = yield* Service79;
+  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 requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError7({ id })))));
+  const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const id = input.id ?? ID9.create();
+    const existing = yield* Cache.getSuccess(forms, id);
+    if (Option.isSome(existing))
+      return yield* new AlreadyExistsError2({ id });
+    const invalid = validateFields2(input.fields);
+    if (invalid)
+      return yield* new InvalidFormError2({ 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* requireEntry(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* requireEntry(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* requireEntry(id)).state;
+  });
+  const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* requireEntry(input.id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ id: input.id });
+    const invalid = validateAnswer2(entry.form.fields, input.answer);
+    if (invalid)
+      return yield* new InvalidAnswerError2({ 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* requireEntry(id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ 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 Service65.of({ create, ask, get, list, state, reply, cancel });
+}));
+var node70 = makeLocationNode({ service: Service65, layer: layer24, deps: [node84] });
+function validateAnswer2(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 validateFields2(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" && !URL.canParse(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 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 { ID9, Info23, Field2, Fields2, When2, State3, Answer2, Reply2, NotFoundError7, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service65, layer24, node70, validateAnswer2, validateFields2, exports_form, Event15 };

package/dist/chunks/worktree-rn1y5g26.js

@@ -0,0 +1,163 @@
+import {
+  ID15
+} from "./worktree-7vcja736.js";
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  Info14
+} from "./worktree-16cax9zb.js";
+import {
+  migrateAgent2
+} from "./worktree-4vfmzcq2.js";
+import {
+  latest2,
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  parseOption2
+} from "./worktree-5daktx2q.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  ConfigAgentPlugin: () => exports_agent,
+  Plugin: () => Plugin19
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Document, Info } from "@opencode/schema/config";
+import { ConfigAgent } from "@opencode/schema/config/agent";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var legacySources = [
+  { pattern: "{agent,agents}/**/*.md", primary: false },
+  { pattern: "{mode,modes}/*.md", primary: true }
+];
+var sourceDirectories = ["agent", "agents", "mode", "modes"];
+var decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info);
+var decodeLegacyAgent = Schema.decodeUnknownOption(Info14);
+var decodeConfig = Schema.decodeUnknownOption(Info);
+var pathActions = ["external_directory", "read", "edit"];
+var agentKeys = new Set(["variant", ...Object.keys(ConfigAgent.Info.fields)]);
+var Plugin19 = define({
+  id: "opencode.config.agent",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service54;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [entry];
+      if (entry.type !== "directory")
+        return [];
+      const files = yield* discover(fs, entry.path);
+      return yield* Effect.forEach(files, (file) => fs.readFileStringSafe(file.filepath).pipe(Effect.map((content) => content ? decode(file, content) : undefined), Effect.orElseSucceed(() => {
+        return;
+      }))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+    });
+    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.agent.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.agent.transform((editor) => {
+      const permissions = expandPermissions(loaded.documents.flatMap((document) => document.info.permissions ?? []), global.home);
+      const configuredDefault = latest2(loaded.documents, "default_agent");
+      if (configuredDefault !== undefined)
+        editor.default(ID15.make(configuredDefault));
+      for (const current of editor.list()) {
+        editor.update(current.id, (agent) => agent.permissions.push(...permissions));
+      }
+      for (const document of loaded.documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = ID15.make(id);
+          if (item.disabled) {
+            editor.remove(agentID);
+            continue;
+          }
+          const exists = editor.get(agentID) !== undefined;
+          editor.update(agentID, (agent) => {
+            if (!exists)
+              agent.permissions.push(...permissions);
+            if (item.model !== undefined)
+              agent.model = {
+                id: item.model.model,
+                providerID: item.model.providerID,
+                ...item.model.variant === undefined ? {} : { variant: item.model.variant }
+              };
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {});
+              Object.assign(agent.request.body, item.request.body ?? {});
+            }
+            if (item.system !== undefined)
+              agent.system = item.system;
+            if (item.description !== undefined)
+              agent.description = item.description;
+            if (item.mode !== undefined)
+              agent.mode = item.mode;
+            if (item.hidden !== undefined)
+              agent.hidden = item.hidden;
+            if (item.color !== undefined)
+              agent.color = item.color;
+            if (item.steps !== undefined)
+              agent.steps = item.steps;
+            if (item.permissions !== undefined) {
+              agent.permissions.push(...expandPermissions(item.permissions, global.home));
+            }
+          });
+        }
+      }
+    });
+  })
+});
+function isAgentSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function expandPermissions(rules, home) {
+  return rules.map((rule) => isPathAction(rule.action) ? { ...rule, resource: expandHome(rule.resource, home) } : rule);
+}
+function isPathAction(action) {
+  return pathActions.some((item) => item === action);
+}
+function expandHome(resource, home) {
+  if (resource === "~" || resource === "$HOME")
+    return home;
+  const relative = resource.startsWith("~/") ? resource.slice(2) : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\") ? resource.slice(6) : undefined;
+  if (relative !== undefined)
+    return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative);
+  return resource;
+}
+function discover(fs, directory) {
+  return Effect.forEach(legacySources, (source) => fs.scan(source.pattern, { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.map((files) => files.toSorted().map((filepath) => ({ directory, filepath, primary: source.primary }))))).pipe(Effect.map((files) => files.flat()), Effect.orElseSucceed(() => []));
+}
+function decode(file, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const name = path.relative(file.directory, file.filepath).replaceAll("\\", "/").replace(/^(agent|agents|mode|modes)\//, "").replace(/\.md$/, "");
+  const body = markdown.content.trim();
+  const legacy = Object.keys(markdown.data).some((key) => !agentKeys.has(key));
+  const agent = legacy ? Option.getOrUndefined(Option.map(decodeLegacyAgent({ name, ...markdown.data, prompt: body }, { errors: "all", propertyOrder: "original" }), migrateAgent2)) : Option.getOrUndefined(decodeAgent({ ...markdown.data, system: body }, { errors: "all", propertyOrder: "original" }));
+  if (!agent)
+    return;
+  const info = Option.getOrUndefined(decodeConfig({
+    agents: { [name]: file.primary ? { ...agent, mode: "primary" } : agent }
+  }));
+  if (!info)
+    return;
+  return new Document({ type: "document", path: AbsolutePath2.make(file.filepath), info });
+}
+
+export { Plugin19, exports_agent };