@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-r9mregkx.js

@@ -0,0 +1,263 @@
+import {
+  definition2,
+  normalizedName2
+} from "./repository-3w5fmr99.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/codemode/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
+});
+import { CodeMode, Namespace, Tool, toolError } from "@opencode/codemode";
+import { Effect, Ref, Schema, Semaphore } from "effect";
+var ExecuteFile = Schema.Struct({
+  data: Schema.String,
+  mime: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+});
+var ExecuteCall = Schema.Struct({
+  tool: Schema.String,
+  status: Schema.Literals(["running", "completed", "error"]),
+  input: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json))
+});
+var ExecuteOutput = Schema.Struct({
+  output: Schema.String,
+  toolCalls: Schema.Array(ExecuteCall),
+  error: Schema.optionalKey(Schema.Literal(true)),
+  files: Schema.Array(ExecuteFile)
+});
+var description = [
+  "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
+  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
+  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
+].join(`
+`);
+var create2 = (inventory, executeTool) => {
+  return {
+    name: "execute",
+    description,
+    input: CodeMode.Input,
+    output: ExecuteOutput,
+    execute: ({ code }, context) => Effect.gen(function* () {
+      const callIndex = yield* Ref.make(0);
+      const files = yield* Ref.make([]);
+      const calls = yield* Ref.make([]);
+      const lock = Semaphore.makeUnsafe(1);
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
+      const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
+        const executed = yield* executeTool(name, tool, input, context);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
+        if (outputFileParts.length > 0)
+          yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
+        if (executed.output !== undefined)
+          return executed.output;
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+        return text === "" ? null : text;
+      }), {
+        onToolCallStart: ({ index, name, input }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = { tool: name, status: "running", ...shown ? { input: shown } : {} };
+            return next;
+          });
+        },
+        onToolCallEnd: ({ index, name, input, outcome }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = {
+              ...items[index] ?? { tool: name, ...shown ? { input: shown } : {} },
+              status: outcome === "success" ? "completed" : "error"
+            };
+            return next;
+          });
+        }
+      }).execute(code);
+      const toolCalls = yield* Ref.get(calls);
+      const collected = (yield* Ref.get(files)).toSorted((left, right) => left.index - right.index).flatMap((item) => item.files);
+      const output = formatResult(result);
+      const value = {
+        output,
+        toolCalls,
+        files: collected,
+        ...result.ok ? {} : { error: true }
+      };
+      const content = [
+        { type: "text", text: value.output },
+        ...value.files.map((file) => ({
+          type: "file",
+          uri: `data:${file.mime};base64,${file.data}`,
+          mime: file.mime,
+          ...file.name === undefined ? {} : { name: file.name }
+        }))
+      ];
+      const metadata = {
+        toolCalls: value.toolCalls,
+        ...value.error ? { error: true } : {}
+      };
+      return {
+        output: value,
+        content,
+        metadata
+      };
+    })
+  };
+};
+var catalog2 = (inventory) => {
+  const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const tool of runtime(inventory, () => Effect.fail(toolError("Execute context is unavailable"))).catalog)
+    getNode(root, tool.path).tool = {
+      type: "tool",
+      name: tool.path.split(".").at(-1) ?? tool.path,
+      description: tool.description,
+      signature: tool.signature,
+      pinned: pinned.has(tool.path)
+    };
+  return {
+    tools: renderCatalog(root)
+  };
+};
+function renderCatalog(root) {
+  return Array.from(root.children).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([name, node]) => {
+    const tools = renderCatalog(node);
+    const namespace = node.namespace === undefined && tools.length === 0 ? undefined : {
+      type: "namespace",
+      name,
+      ...node.namespace?.description === undefined ? {} : { description: node.namespace.description },
+      tools
+    };
+    if (node.tool === undefined)
+      return namespace === undefined ? [] : [namespace];
+    if (namespace === undefined)
+      return [node.tool];
+    return [node.tool, namespace];
+  });
+}
+function runtime(inventory, executeTool, hooks) {
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const [name, registration] of inventory.tools) {
+    const child = definition2(registration);
+    getNode(root, qualifiedName(registration)).tool = Tool.make({
+      description: child.description,
+      input: child.inputSchema,
+      output: child.outputSchema ?? Schema.NullOr(Schema.String),
+      execute: (input) => executeTool(name, registration, input)
+    });
+  }
+  const tools = renderTools(root);
+  return CodeMode.make({ tools, ...hooks });
+}
+function getNode(root, path) {
+  return path.split(".").reduce((parent, name) => {
+    const child = parent.children.get(name) ?? { children: new Map };
+    parent.children.set(name, child);
+    return child;
+  }, root);
+}
+function renderTools(root) {
+  const callables = new Map;
+  const tools = renderChildren(root, [], callables);
+  for (const [path, tool] of callables)
+    tools[path] = tool;
+  return tools;
+}
+function renderChildren(node, path, callables) {
+  return Object.fromEntries(Array.from(node.children).flatMap(([name, child]) => {
+    const next = [...path, name];
+    if (path.length === 0 && child.tool !== undefined && (child.namespace !== undefined || child.children.size > 0)) {
+      const tools = {};
+      flattenTools(child, next, tools);
+      return Object.entries(tools);
+    }
+    return [[name, renderEntry(child, next, callables)]];
+  }));
+}
+function renderEntry(node, path, callables) {
+  const tools = renderChildren(node, path, callables);
+  if (node.tool !== undefined && (node.namespace !== undefined || node.children.size > 0))
+    callables.set(path.join("."), node.tool);
+  if (node.namespace !== undefined)
+    return Namespace.make({
+      description: node.namespace.description,
+      tools
+    });
+  if (node.tool === undefined)
+    return tools;
+  if (node.children.size === 0)
+    return node.tool;
+  return tools;
+}
+function flattenTools(node, path, tools) {
+  if (node.tool !== undefined)
+    tools[path.join(".")] = node.tool;
+  for (const [name, child] of node.children)
+    flattenTools(child, [...path, name], tools);
+}
+function qualifiedName(registration) {
+  const normalized = normalizedName2(registration);
+  if (registration.options?.namespace === undefined)
+    return normalized;
+  return `${registration.options.namespace}.${normalized}`;
+}
+function displayInput(input) {
+  if (input === null || input === undefined)
+    return;
+  if (typeof input !== "object" || Array.isArray(input))
+    return { input };
+  if (Object.keys(input).length === 0)
+    return;
+  return input;
+}
+function formatResult(result) {
+  const output = result.ok ? formatValue(result.value) : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))].join(`
+`).trim();
+  const warnings = result.ok && result.warnings && result.warnings.length > 0 ? `Warnings:
+${result.warnings.map((item) => `- [${item.kind}] ${item.message}`).join(`
+`)}` : undefined;
+  const logs = result.logs && result.logs.length > 0 ? `Logs:
+${result.logs.join(`
+`)}` : undefined;
+  return [output, warnings, logs].filter((part) => part !== undefined && part !== "").join(`
+
+`);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function outputFiles(content) {
+  return content.flatMap((part) => {
+    if (part.type !== "file")
+      return [];
+    const prefix = `data:${part.mime};base64,`;
+    if (!part.uri.startsWith(prefix))
+      return [];
+    return [
+      {
+        data: part.uri.slice(prefix.length),
+        mime: part.mime,
+        ...part.name === undefined ? {} : { name: part.name }
+      }
+    ];
+  });
+}
+
+export { create2, catalog2, exports_tool2 };

package/dist/chunks/repository-rcb2kzg1.js

@@ -0,0 +1,21 @@
+// src/database/migration/20260225215848_workspace.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260225215848_workspace",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`branch\` text,
+          \`project_id\` text NOT NULL,
+          \`config\` text NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260225215848_workspace_default = migration;
+
+export { _20260225215848_workspace_default };

package/dist/chunks/repository-rg2zvvyz.js

@@ -0,0 +1,46 @@
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service80
+} from "./repository-drknmmyh.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/image.ts
+var exports_image = {};
+__export(exports_image, {
+  ConfigImagePlugin: () => exports_image,
+  Plugin: () => Plugin11
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin11 = define({
+  id: "opencode.config.image",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const image = yield* Service80;
+    const loaded = yield* observe2(config, ctx.event, image.reload());
+    yield* image.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document")
+          continue;
+        const configured = entry.info.media?.image;
+        if (!configured)
+          continue;
+        editor.configure({
+          ...configured.auto_resize === undefined ? {} : { autoResize: configured.auto_resize },
+          ...configured.max_width === undefined ? {} : { maxWidth: configured.max_width },
+          ...configured.max_height === undefined ? {} : { maxHeight: configured.max_height },
+          ...configured.max_base64_bytes === undefined ? {} : { maxBase64Bytes: configured.max_base64_bytes }
+        });
+      }
+    });
+  })
+});
+
+export { Plugin11, exports_image };

package/dist/chunks/repository-rgmexsye.js

@@ -0,0 +1,118 @@
+import {
+  Service77
+} from "./repository-yz39bey7.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/question.ts
+var exports_question = {};
+__export(exports_question, {
+  CancelledError: () => CancelledError2,
+  Input: () => Input14,
+  Output: () => Output9,
+  Plugin: () => Plugin45,
+  QuestionTool: () => exports_question,
+  description: () => description6,
+  name: () => name14,
+  toModelContent: () => toModelContent7
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { Question } from "@opencode/schema/question";
+var name14 = "question";
+var description6 = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- A "Type your own answer" option is added automatically; don't include a separate option for free form answers
+- Set \`multiple: true\` to allow selecting more than one option
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
+var Input14 = Schema.Struct({
+  questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
+});
+var Output9 = Schema.Struct({
+  answers: Schema.Array(Question.Answer)
+});
+
+class CancelledError2 extends Schema.TaggedError()("QuestionTool.CancelledError", {}) {
+  get message() {
+    return "The user dismissed this question";
+  }
+}
+var toModelContent7 = (questions, answers) => {
+  const formatted = questions.map((question, index) => `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`).join(", ");
+  return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+};
+var Plugin45 = {
+  id: "opencode.tool.question",
+  effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
+    const forms = yield* Service77;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name14,
+      options: { codemode: false },
+      description: description6,
+      input: Input14,
+      output: Output9,
+      execute: (input, context) => permission.assert({
+        action: "question",
+        resources: ["*"],
+        sessionID: context.sessionID,
+        agent: context.agent,
+        source: { type: "tool", messageID: context.messageID, id: context.id }
+      }).pipe(Effect.mapError((error) => new ToolFailure({ message: "Permission denied: question", error })), Effect.andThen(forms.ask({
+        sessionID: context.sessionID,
+        title: "Questions",
+        metadata: {
+          kind: "question",
+          tool: { messageID: context.messageID, id: context.id }
+        },
+        fields: [
+          toField(input.questions[0], 0),
+          ...input.questions.slice(1).map((question, index) => toField(question, index + 1))
+        ]
+      }).pipe(Effect.orDie)), Effect.flatMap((state) => {
+        if (state.status === "cancelled")
+          return Effect.die(new CancelledError2);
+        const output = {
+          answers: input.questions.map((_, index) => {
+            const value = state.answer[`q${index}`];
+            if (value === undefined)
+              return [];
+            if (typeof value === "object")
+              return Array.from(value);
+            return [String(value)];
+          })
+        };
+        return Effect.succeed({
+          output,
+          content: toModelContent7(input.questions, output.answers),
+          metadata: { answers: output.answers }
+        });
+      }))
+    })).pipe(Effect.orDie);
+  })
+};
+function toField(question, index) {
+  return {
+    key: `q${index}`,
+    title: question.header,
+    description: question.question,
+    type: question.multiple === true ? "multiselect" : "string",
+    options: question.options.map((option) => ({
+      value: option.label,
+      label: option.label,
+      description: option.description
+    })),
+    custom: true
+  };
+}
+
+export { name14, description6, Input14, Output9, CancelledError2, toModelContent7, Plugin45, exports_question };

package/dist/chunks/repository-rhjbct0v.js

@@ -0,0 +1,196 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/instructions/index.ts
+var exports_instructions6 = {};
+__export(exports_instructions6, {
+  Delta: () => Delta2,
+  DuplicateKeyError: () => DuplicateKeyError2,
+  Hash: () => Hash2,
+  InitializationBlocked: () => InitializationBlocked2,
+  Instructions: () => exports_instructions6,
+  Key: () => Key3,
+  Values: () => Values2,
+  applyHashDelta: () => applyHashDelta2,
+  combine: () => combine2,
+  diff: () => diff2,
+  diffByKey: () => diffByKey2,
+  empty: () => empty3,
+  hash: () => hash2,
+  make: () => make20,
+  read: () => read3,
+  removed: () => removed2,
+  renderInitial: () => renderInitial2,
+  renderUpdate: () => renderUpdate2,
+  unavailable: () => unavailable3
+});
+import { createHash } from "crypto";
+import { Instruction } from "@opencode/schema/instruction";
+import { Data, Effect, Option, Schema } from "effect";
+var Key3 = Instruction.Key;
+var Hash2 = Instruction.Hash;
+var Values2 = Instruction.Values;
+var Delta2 = Instruction.Delta;
+var NonValue = Data.taggedEnum();
+var unavailable3 = NonValue.Unavailable();
+var removed2 = NonValue.Removed();
+
+class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key3) }) {
+  get message() {
+    return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
+  }
+}
+
+class DuplicateKeyError2 extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
+  key: Key3
+}) {
+  get message() {
+    return `Duplicate instruction key: ${this.key}`;
+  }
+}
+var empty3 = [];
+function make20(source) {
+  const decode = Schema.decodeUnknownOption(source.codec);
+  const encode = Schema.encodeSync(source.codec);
+  const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
+  const decodeValue = (value) => Option.getOrUndefined(decode(value));
+  return [
+    {
+      key: source.key,
+      read: source.read.pipe(Effect.map((value) => {
+        if (isUnavailable(value))
+          return unavailable3;
+        if (isRemoved(value))
+          return removed2;
+        return encode(value);
+      })),
+      initial: (value) => {
+        const decoded = decodeValue(value);
+        return decoded === undefined ? undefined : initial(decoded);
+      },
+      changed: (previous, current) => {
+        const before = decodeValue(previous);
+        const after = decodeValue(current);
+        if (after === undefined)
+          return;
+        if (before === undefined)
+          return initial(after);
+        return requireText(source.key, "changed", source.render.changed(before, after));
+      },
+      removed: (previous) => {
+        const decoded = decodeValue(previous);
+        return decoded === undefined || source.render.removed === undefined ? undefined : requireText(source.key, "removed", source.render.removed(decoded));
+      }
+    }
+  ];
+}
+function combine2(values) {
+  const sources = values.flat();
+  const keys = new Set;
+  for (const source of sources) {
+    if (keys.has(source.key))
+      throw new DuplicateKeyError2({ key: source.key });
+    keys.add(source.key);
+  }
+  return sources;
+}
+function read3(value) {
+  return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
+}
+function diff2(observed, previous) {
+  const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
+  if (blocked.length > 0)
+    return Effect.fail(new InitializationBlocked2({ keys: blocked }));
+  const delta = {};
+  const blobs = {};
+  for (const entry of observed) {
+    if (isUnavailable(entry.value))
+      continue;
+    if (isRemoved(entry.value)) {
+      if (previous && Object.hasOwn(previous, entry.key))
+        delta[entry.key] = Instruction.removed;
+      continue;
+    }
+    const next = hash2(entry.value);
+    if (previous?.[entry.key] === next)
+      continue;
+    delta[entry.key] = next;
+    blobs[next] = entry.value;
+  }
+  return Effect.succeed({ delta, blobs });
+}
+function renderInitial2(value, values) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(values, source.key))
+      return [];
+    const text = source.initial(values[source.key]);
+    return text === undefined ? [] : [text];
+  }));
+}
+function renderUpdate2(value, previous, delta) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(delta, source.key))
+      return [];
+    const current = delta[source.key];
+    if (Option.isNone(current)) {
+      if (!Object.hasOwn(previous, source.key))
+        return [];
+      const text = source.removed(previous[source.key]);
+      return text === undefined ? [] : [text];
+    }
+    const next = current.value;
+    const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
+    return text === undefined ? [] : [text];
+  }));
+}
+function hash2(value) {
+  return Hash2.make(createHash("sha256").update(canonical(value)).digest("hex"));
+}
+function applyHashDelta2(values, delta) {
+  const result = { ...values };
+  for (const [key, value] of Object.entries(delta)) {
+    if (value === Instruction.removed)
+      delete result[key];
+    else
+      result[key] = value;
+  }
+  return result;
+}
+function diffByKey2(previous, current, key, changed) {
+  const currentKeys = new Set(current.map(key));
+  const previousByKey = new Map(previous.map((value) => [key(value), value]));
+  return {
+    added: current.filter((value) => !previousByKey.has(key(value))),
+    removed: previous.filter((value) => !currentKeys.has(key(value))),
+    changed: current.flatMap((value) => {
+      const before = previousByKey.get(key(value));
+      return before === undefined || !changed(before, value) ? [] : [{ previous: before, current: value }];
+    })
+  };
+}
+function render(parts) {
+  return parts.join(`
+
+`);
+}
+function isUnavailable(value) {
+  return value === unavailable3;
+}
+function isRemoved(value) {
+  return value === removed2;
+}
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function requireText(key, kind, text) {
+  if (text.length === 0)
+    throw new Error(`Instruction source ${key} rendered an empty ${kind}`);
+  return text;
+}
+
+export { Key3, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make20, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };