@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-16cax9zb.js

@@ -0,0 +1,74 @@
+import {
+  PositiveInt2
+} from "./worktree-922hggd3.js";
+import {
+  Info16
+} from "./worktree-g190xswt.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/agent.ts
+var exports_agent3 = {};
+__export(exports_agent3, {
+  ConfigAgentV1: () => exports_agent3,
+  Info: () => Info14
+});
+import { Schema, SchemaGetter } from "effect";
+var Color = Schema.Union([
+  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"])
+]);
+var AgentSchema = Schema.StructWithRest(Schema.Struct({
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String).annotate({
+    description: "Default model variant for this agent (applies only when using the agent's configured model)."
+  }),
+  temperature: Schema.optional(Schema.Finite),
+  top_p: Schema.optional(Schema.Finite),
+  prompt: Schema.optional(Schema.String),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description: "@deprecated Use 'permission' field instead"
+  }),
+  disable: Schema.optional(Schema.Boolean),
+  description: Schema.optional(Schema.String).annotate({ description: "Description of when to use the agent" }),
+  mode: Schema.optional(Schema.Literals(["subagent", "primary", "all"])),
+  hidden: Schema.optional(Schema.Boolean).annotate({
+    description: "Hide this subagent from the @ autocomplete menu (default: false, only applies to mode: subagent)"
+  }),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  color: Schema.optional(Color).annotate({
+    description: "Hex color code (e.g., #FF5733) or theme color (e.g., primary)"
+  }),
+  steps: Schema.optional(PositiveInt2).annotate({
+    description: "Maximum number of agentic iterations before forcing text-only response"
+  }),
+  maxSteps: Schema.optional(PositiveInt2).annotate({ description: "@deprecated Use 'steps' field instead." }),
+  permission: Schema.optional(Info16)
+}), [Schema.Record(Schema.String, Schema.Any)]);
+var KNOWN_KEYS = new Set(["name", ...Object.keys(AgentSchema.schema.fields)]);
+var normalize = (agent) => {
+  const options = { ...agent.options };
+  for (const [key, value] of Object.entries(agent)) {
+    if (!KNOWN_KEYS.has(key))
+      options[key] = value;
+  }
+  const permission = {};
+  for (const [tool, enabled] of Object.entries(agent.tools ?? {})) {
+    const action = enabled ? "allow" : "deny";
+    if (tool === "write" || tool === "edit" || tool === "patch") {
+      permission.edit = action;
+      continue;
+    }
+    permission[tool] = action;
+  }
+  globalThis.Object.assign(permission, agent.permission);
+  const steps = agent.steps ?? agent.maxSteps;
+  return { ...agent, options, permission, ...steps !== undefined ? { steps } : {} };
+};
+var Info14 = AgentSchema.pipe(Schema.decodeTo(AgentSchema, {
+  decode: SchemaGetter.transform(normalize),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "AgentConfig" });
+
+export { Info14, exports_agent3 };

package/dist/chunks/worktree-17cy0kzp.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260603040000_session_message_projection_order.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603040000_session_message_projection_order",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`ALTER TABLE \`session_message\` ADD COLUMN \`seq\` integer NOT NULL;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_type_time_created_id_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+    });
+  }
+};
+var _20260603040000_session_message_projection_order_default = migration;
+
+export { _20260603040000_session_message_projection_order_default };

package/dist/chunks/worktree-18bdr5q6.js

@@ -0,0 +1,101 @@
+import {
+  Service52
+} from "./worktree-pr7ch8ks.js";
+import {
+  Service51,
+  readText2,
+  syncTextBom2
+} from "./worktree-nsx3nvvw.js";
+import {
+  Service15
+} from "./worktree-8mvsftc3.js";
+import {
+  Service70
+} from "./worktree-k56d8zdx.js";
+import {
+  Service69
+} from "./worktree-13bmfrpk.js";
+import {
+  fileDiff2
+} from "./worktree-6prwharc.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/write.ts
+var exports_write = {};
+__export(exports_write, {
+  Input: () => Input4,
+  Output: () => Output2,
+  Plugin: () => Plugin5,
+  WriteTool: () => exports_write,
+  name: () => name4,
+  toModelContent: () => toModelContent2
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+var name4 = "write";
+var Input4 = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "Path to the file to write to"
+  }),
+  content: Schema.String.annotate({ description: "Content to write to the file" })
+});
+var Output2 = Schema.Struct({
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean
+});
+var toModelContent2 = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin5 = {
+  id: "opencode.tool.write",
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
+    const access = yield* Service69;
+    const fileMutation = yield* Service51;
+    const environment = yield* Service52;
+    const formatter = yield* Service15;
+    const permission = yield* Service70;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name4,
+      options: { codemode: false, permission: "edit" },
+      description: `Writes a file to the local filesystem, overwriting if one exists.
+
+Missing parent directories are created automatically.
+
+Use this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.`,
+      input: Input4,
+      output: Output2,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const target = yield* access.resolve({ path: input.path, kind: "file" });
+        yield* access.authorizeExternal([target], context);
+        const current = yield* readText2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.undefined));
+        const next = Bom.split(input.content);
+        const preview = fileDiff2(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        yield* permission.assert({
+          action: "edit",
+          resources: [target.resource],
+          save: ["*"],
+          metadata: { files: [preview] },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
+        const bom = (yield* readText2(environment.files, target.absolute)).bom;
+        if (yield* formatter.file(target.absolute)) {
+          yield* syncTextBom2(environment.files, target.absolute, bom);
+        }
+        return result;
+      }).pipe(Effect.map((output) => ({ output, content: toModelContent2(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name4, Input4, Output2, toModelContent2, Plugin5, exports_write };

package/dist/chunks/worktree-1cgg357y.js

@@ -0,0 +1,55 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  Plugin: () => Plugin44,
+  VariantPlugin: () => exports_variant,
+  generate: () => generate2
+});
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Model } from "@opencode/schema/model";
+var Plugin44 = define({
+  id: "opencode.variant",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((catalog) => {
+      for (const record of catalog.provider.list()) {
+        for (const model of record.models.values()) {
+          catalog.model.update(model.providerID, model.id, (draft) => {
+            const generated = generate2(draft, record.provider);
+            if (generated.length === 0)
+              return;
+            const variants = draft.variants ?? [];
+            const explicit = new Map(variants.map((variant) => [variant.id, variant]));
+            const generatedIDs = new Set(generated.map((variant) => variant.id));
+            draft.variants = [
+              ...generated.map((variant) => explicit.get(variant.id) ?? variant),
+              ...variants.filter((variant) => !generatedIDs.has(variant.id))
+            ];
+          });
+        }
+      }
+    });
+  })
+});
+function generate2(model, provider) {
+  const packageName = model.package ?? provider?.package;
+  if (!isAISDK2(packageName) || packageName2(packageName) !== "@ai-sdk/openai-compatible")
+    return [];
+  const ids = `${model.id} ${model.modelID ?? ""}`.toLowerCase();
+  if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
+    return [];
+  return ["high", "max"].map((id) => ({
+    id: Model.VariantID.make(id),
+    settings: { reasoningEffort: id }
+  }));
+}
+
+export { Plugin44, generate2, exports_variant };

package/dist/chunks/worktree-1cnp2v09.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260213144116_wakeful_the_professor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260213144116_wakeful_the_professor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`control_account\` (
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`active\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
+        );
+      `);
+    });
+  }
+};
+var _20260213144116_wakeful_the_professor_default = migration;
+
+export { _20260213144116_wakeful_the_professor_default };

package/dist/chunks/worktree-1dazxqgg.js

@@ -0,0 +1,154 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./worktree-2a5m3afh.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/environment/exec-defaults.ts
+var exports_exec_defaults = {};
+__export(exports_exec_defaults, {
+  EnvironmentExecDefaults: () => exports_exec_defaults,
+  execDefaults: () => execDefaults2
+});
+import { Effect, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { collectStream } from "@opencode/util/process";
+var MAX_DATA_BYTES = 64 * 1024 * 1024;
+var MAX_ERROR_BYTES = 64 * 1024;
+var NOT_FOUND = 44;
+var WRONG_KIND = 45;
+var FAILED = 46;
+var TAB = "\t";
+var loadMetadata = (flags = "") => `
+metadata=$(stat ${flags} -c '%F${TAB}%s${TAB}%Y' -- "$1" 2>&1) || {
+  case "$metadata" in
+    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
+    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
+  esac
+}
+`;
+var statScript = `
+${loadMetadata()}
+printf '%s
+' "$metadata"
+`;
+var readScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+printf '%s
+' "$metadata"
+if [ "$2" = range ]; then
+  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
+else
+  cat -- "$1"
+fi
+`;
+var listScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != directory ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+find -H "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
+`;
+var moveScript = `
+${loadMetadata()}
+mv -- "$1" "$2"
+`;
+var execDefaults2 = (spawner) => {
+  const run = (path, script, args = [], stdin) => Effect.scoped(Effect.gen(function* () {
+    const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
+      env: { LC_ALL: "C" },
+      extendEnv: true,
+      stdin: stdin === undefined ? undefined : Stream.make(stdin)
+    });
+    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed2({ path, cause })));
+    const [stdout, stderr, exitCode] = yield* Effect.all([
+      collectStream(handle.stdout, MAX_DATA_BYTES),
+      collectStream(handle.stderr, MAX_ERROR_BYTES),
+      handle.exitCode
+    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed2({ path, cause })));
+    if (stdout.truncated || stderr.truncated) {
+      return yield* new Failed2({ path, cause: new Error("Process output exceeded its collection limit") });
+    }
+    return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer };
+  }));
+  const classify = (path, result, success) => {
+    if (result.exitCode === 0)
+      return Effect.sync(() => success(result.stdout));
+    if (result.exitCode === NOT_FOUND)
+      return Effect.fail(new NotFound2({ path }));
+    if (result.exitCode === WRONG_KIND) {
+      return Effect.fail(new WrongKind2({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
+    }
+    return Effect.fail(processFailure(path, result));
+  };
+  const complete = (path, result) => result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result));
+  return {
+    stat: (path) => run(path, statScript).pipe(Effect.flatMap((result) => classifyPlain(path, result, parseInfo))),
+    read: (path, range) => run(path, readScript, range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)]).pipe(Effect.flatMap((result) => classify(path, result, (stdout) => {
+      const newline = stdout.indexOf(10);
+      if (newline < 0)
+        throw new Error("Missing read metadata header");
+      return {
+        info: parseInfo(stdout.slice(0, newline)),
+        bytes: stdout.slice(newline + 1)
+      };
+    }))),
+    write: (path, bytes) => run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(Effect.flatMap((result) => complete(path, result))),
+    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
+    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+    move: (from, to) => run(from, moveScript, [to]).pipe(Effect.flatMap((result) => classifyPlain(from, result, () => {
+      return;
+    }))),
+    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result)))
+  };
+};
+var classifyPlain = (path, result, success) => {
+  if (result.exitCode === 0)
+    return Effect.sync(() => success(result.stdout));
+  if (result.exitCode === NOT_FOUND)
+    return Effect.fail(new NotFound2({ path }));
+  return Effect.fail(processFailure(path, result));
+};
+var processFailure = (path, result) => new Failed2({
+  path,
+  cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`)
+});
+var parseInfo = (bytes) => {
+  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split(TAB);
+  const size = Number(rawSize);
+  const mtimeMs = Number(rawMtime) * 1000;
+  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs))
+    throw new Error("Invalid stat output");
+  return { type: parseType(rawType), size, mtimeMs };
+};
+var parseType = (value) => {
+  if (value === "regular file" || value === "regular empty file" || value === "f")
+    return "file";
+  if (value === "directory" || value === "d")
+    return "directory";
+  if (value === "symbolic link" || value === "l")
+    return "symlink";
+  return "other";
+};
+var parseList = (bytes) => {
+  const fields = new TextDecoder().decode(bytes).split("\x00");
+  fields.pop();
+  if (fields.length % 2 !== 0)
+    throw new Error("Invalid find output");
+  return Array.from({ length: fields.length / 2 }, (_, index) => ({
+    name: fields[index * 2 + 1],
+    type: parseType(fields[index * 2])
+  }));
+};
+
+export { execDefaults2, exports_exec_defaults };