@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-rt6yg6j2.js

@@ -0,0 +1,338 @@
+import {
+  MAX_PATCH_BYTES,
+  MAX_TOTAL_PATCH_BYTES,
+  PATCH_CONTEXT_LINES,
+  chunksByFile,
+  emptyPatch
+} from "./permission-vz89hfgr.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/vcs/git.ts
+var exports_git = {};
+__export(exports_git, {
+  make: () => make,
+  VcsGit: () => exports_git
+});
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make(proc, input) {
+  const ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree };
+  return {
+    info: Effect.fn("VcsGit.info")(function* () {
+      const [current, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
+        concurrency: 2
+      });
+      return { branch: { current, default: root?.name } };
+    }),
+    status: Effect.fn("VcsGit.status")(function* () {
+      const git = ctx.git;
+      const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined;
+      const [list, stats] = yield* Effect.all([git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])], { concurrency: 2 });
+      const map = nums(stats);
+      return yield* Effect.forEach(list.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined);
+        return {
+          file: item.file,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsGit.diff")(function* (mode, options) {
+      const git = ctx.git;
+      if (mode === "working") {
+        return yield* track(ctx, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options);
+      }
+      const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
+        concurrency: 2
+      });
+      if (!root)
+        return [];
+      if (current && current === root.name)
+        return [];
+      const ref = yield* git.mergeBase(ctx.directory, root.ref);
+      if (!ref)
+        return [];
+      return yield* diffAgainstRef(ctx, ref, options);
+    })
+  };
+}
+var cfg = [
+  "--no-optional-locks",
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "core.longpaths=true",
+  "-c",
+  "core.symlinks=true",
+  "-c",
+  "core.quotepath=false"
+];
+var kind = (code) => {
+  if (code === "??")
+    return "added";
+  if (code.includes("U"))
+    return "modified";
+  if (code.includes("A") && !code.includes("D"))
+    return "added";
+  if (code.includes("D") && !code.includes("A"))
+    return "deleted";
+  return "modified";
+};
+var nuls = (text) => text.split("\x00").filter(Boolean);
+function makeGit(proc) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("git", [...cfg, ...args], {
+      cwd: opts.cwd,
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.catch(() => Effect.succeed({ exitCode: 1, text: () => "", truncated: false })));
+  const text = Effect.fnUntraced(function* (args, opts) {
+    return (yield* run(args, opts)).text();
+  });
+  const lines = Effect.fnUntraced(function* (args, opts) {
+    return (yield* text(args, opts)).split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+  });
+  const configured = Effect.fnUntraced(function* (cwd, list) {
+    const result = yield* run(["config", "init.defaultBranch"], { cwd });
+    const name = result.text().trim();
+    if (!name || !list.includes(name))
+      return;
+    return { name, ref: name };
+  });
+  const primary = Effect.fnUntraced(function* (cwd) {
+    const list = yield* lines(["remote"], { cwd });
+    if (list.includes("origin"))
+      return "origin";
+    if (list.length === 1)
+      return list[0];
+    if (list.includes("upstream"))
+      return "upstream";
+    return list[0];
+  });
+  const branch = Effect.fn("VcsGit.branch")(function* (cwd) {
+    const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const defaultBranch = Effect.fn("VcsGit.defaultBranch")(function* (cwd) {
+    const remote = yield* primary(cwd);
+    if (remote) {
+      const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd });
+      if (head.exitCode === 0) {
+        const ref = head.text().trim().replace(/^refs\/remotes\//, "");
+        const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : "";
+        if (name)
+          return { name, ref };
+      }
+    }
+    const list = yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd });
+    const next = yield* configured(cwd, list);
+    if (next)
+      return next;
+    if (list.includes("main"))
+      return { name: "main", ref: "main" };
+    if (list.includes("master"))
+      return { name: "master", ref: "master" };
+  });
+  const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
+    const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
+    return result.exitCode === 0;
+  });
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const result = yield* run(["merge-base", base, "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const status = Effect.fn("VcsGit.statusNames")(function* (cwd) {
+    return nuls(yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], { cwd })).flatMap((item) => {
+      const file = item.slice(3);
+      if (!file)
+        return [];
+      const code = item.slice(0, 2);
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref) {
+    const list = nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, "--", "."], { cwd }));
+    return list.flatMap((code, idx) => {
+      if (idx % 2 !== 0)
+        return [];
+      const file = list[idx + 1];
+      if (!code || !file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref) {
+    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, "--", "."], { cwd })).flatMap((item) => {
+      const a = item.indexOf("\t");
+      const b = item.indexOf("\t", a + 1);
+      if (a === -1 || b === -1)
+        return [];
+      const file = item.slice(b + 1);
+      if (!file)
+        return [];
+      const adds = item.slice(0, a);
+      const dels = item.slice(a + 1, b);
+      const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10);
+      const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10);
+      return [
+        {
+          file,
+          additions: Number.isFinite(additions) ? additions : 0,
+          deletions: Number.isFinite(deletions) ? deletions : 0
+        }
+      ];
+    });
+  });
+  const patch = Effect.fn("VcsGit.patch")(function* (cwd, ref, file, options) {
+    const result = yield* run(["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", file], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const patchAll = Effect.fn("VcsGit.patchAll")(function* (cwd, ref, options) {
+    const result = yield* run(["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", "."], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const patchUntracked = Effect.fn("VcsGit.patchUntracked")(function* (cwd, file, options) {
+    const result = yield* run([
+      "diff",
+      "--no-index",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      "--",
+      "/dev/null",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const statUntracked = Effect.fn("VcsGit.statUntracked")(function* (cwd, file) {
+    const result = yield* run(["diff", "--no-index", "--numstat", "--", "/dev/null", file], {
+      cwd,
+      maxOutputBytes: 4096
+    });
+    if (result.truncated)
+      return;
+    const parts = result.text().split("\t");
+    if (parts.length < 2)
+      return;
+    const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] || "0", 10);
+    const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] || "0", 10);
+    return {
+      file,
+      additions: Number.isFinite(additions) ? additions : 0,
+      deletions: Number.isFinite(deletions) ? deletions : 0
+    };
+  });
+  return {
+    branch,
+    defaultBranch,
+    hasHead,
+    mergeBase,
+    status,
+    diff,
+    stats,
+    patch,
+    patchAll,
+    patchUntracked,
+    statUntracked
+  };
+}
+var nums = (list) => new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }]));
+var merge = (...lists) => {
+  const out = new Map;
+  lists.flat().forEach((item) => {
+    if (!out.has(item.file))
+      out.set(item.file, item);
+  });
+  return [...out.values()];
+};
+var emptyBatch = () => ({ patches: new Map, capped: false });
+var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
+  if (list.length === 0)
+    return emptyBatch();
+  const result = yield* ctx.git.patchAll(ctx.directory, ref, {
+    context: options?.context ?? PATCH_CONTEXT_LINES,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES
+  });
+  return {
+    patches: chunksByFile(result, (index) => list[index]?.file),
+    capped: result.truncated
+  };
+});
+var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
+  const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
+    context: options?.context ?? PATCH_CONTEXT_LINES,
+    maxOutputBytes: MAX_PATCH_BYTES
+  }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
+    context: options?.context ?? PATCH_CONTEXT_LINES,
+    maxOutputBytes: MAX_PATCH_BYTES
+  });
+  if (!result.truncated && result.text)
+    return result.text;
+  return emptyPatch(item.file);
+});
+var totalPatch = (file, patch, total) => {
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES)
+    return { patch, capped: false };
+  return { patch: emptyPatch(file), capped: true };
+};
+var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
+  if (capped)
+    return emptyPatch(item.file);
+  const batched = batch.patches.get(item.file);
+  if (batched !== undefined)
+    return batched;
+  if (item.code !== "??" && batch.capped)
+    return emptyPatch(item.file);
+  return yield* nativePatch(ctx, ref, item, options);
+});
+var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
+  const next = [];
+  let total = 0;
+  let capped = false;
+  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
+    const stat = map.get(item.file) ?? (item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
+    const patch = yield* patchForItem(ctx, ref, item, batch, capped, options);
+    const result = capped ? { patch, capped: true } : totalPatch(item.file, patch, total);
+    capped = capped || result.capped;
+    if (!capped) {
+      total += Buffer.byteLength(result.patch);
+      capped = total >= MAX_TOTAL_PATCH_BYTES;
+    }
+    next.push({
+      file: item.file,
+      patch: result.patch,
+      additions: stat?.additions ?? 0,
+      deletions: stat?.deletions ?? 0,
+      status: item.status
+    });
+  }
+  return next;
+});
+var diffAgainstRef = Effect.fnUntraced(function* (ctx, ref, options) {
+  const [list, stats, extra] = yield* Effect.all([ctx.git.diff(ctx.directory, ref), ctx.git.stats(ctx.directory, ref), ctx.git.status(ctx.directory)], { concurrency: 3 });
+  return yield* files(ctx, ref, merge(list, extra.filter((item) => item.code === "??")), nums(stats), yield* batchPatches(ctx, ref, list, options), options);
+});
+var track = Effect.fnUntraced(function* (ctx, ref, options) {
+  if (!ref)
+    return yield* files(ctx, ref, yield* ctx.git.status(ctx.directory), new Map, emptyBatch(), options);
+  return yield* diffAgainstRef(ctx, ref, options);
+});
+
+export { make, exports_git };

package/dist/chunks/permission-rvfvac9x.js

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __export, __require };

package/dist/chunks/permission-ryap75b3.js

@@ -0,0 +1,261 @@
+import {
+  localShellInputSchema,
+  localShellOutputSchema
+} from "./permission-dbah77c1.js";
+
+// src/github-copilot/responses/convert-to-openai-responses-input.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { convertToBase64, parseProviderOptions } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+function isFileId(data, prefixes) {
+  if (!prefixes)
+    return false;
+  return prefixes.some((prefix) => data.startsWith(prefix));
+}
+async function convertToOpenAIResponsesInput({
+  prompt,
+  systemMessageMode,
+  fileIdPrefixes,
+  store,
+  hasLocalShellTool = false
+}) {
+  const input = [];
+  const warnings = [];
+  const processedApprovalIds = new Set;
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            input.push({ role: "system", content });
+            break;
+          }
+          case "developer": {
+            input.push({ role: "developer", content });
+            break;
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model"
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck = systemMessageMode;
+            throw new Error(`Unsupported system message mode: ${_exhaustiveCheck}`);
+          }
+        }
+        break;
+      }
+      case "user": {
+        input.push({
+          role: "user",
+          content: content.map((part, index) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "input_image",
+                    ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
+                      image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    detail: part.providerOptions?.copilot?.imageDetail
+                  };
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    return {
+                      type: "input_file",
+                      file_url: part.data.toString()
+                    };
+                  }
+                  return {
+                    type: "input_file",
+                    ...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
+                      filename: part.filename ?? `part-${index}.pdf`,
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+                    }
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        const reasoningMessages = {};
+        const toolCallParts = {};
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              input.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }],
+                id: store ? part.providerOptions?.copilot?.itemId ?? undefined : undefined
+              });
+              break;
+            }
+            case "tool-call": {
+              toolCallParts[part.toolCallId] = part;
+              if (part.providerExecuted) {
+                break;
+              }
+              if (hasLocalShellTool && part.toolName === "local_shell") {
+                const parsedInput = localShellInputSchema.parse(part.input);
+                input.push({
+                  type: "local_shell_call",
+                  call_id: part.toolCallId,
+                  id: store ? part.providerOptions?.copilot?.itemId ?? undefined : undefined,
+                  action: {
+                    type: "exec",
+                    command: parsedInput.action.command,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    user: parsedInput.action.user,
+                    working_directory: parsedInput.action.workingDirectory,
+                    env: parsedInput.action.env
+                  }
+                });
+                break;
+              }
+              input.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                id: store ? part.providerOptions?.copilot?.itemId ?? undefined : undefined
+              });
+              break;
+            }
+            case "tool-result": {
+              if (store) {
+                input.push({ type: "item_reference", id: part.toolCallId });
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`
+                });
+              }
+              break;
+            }
+            case "reasoning": {
+              const providerOptions = await parseProviderOptions({
+                provider: "copilot",
+                providerOptions: part.providerOptions,
+                schema: openaiResponsesReasoningProviderOptionsSchema
+              });
+              const reasoningId = providerOptions?.itemId;
+              if (reasoningId != null) {
+                const reasoningMessage = reasoningMessages[reasoningId];
+                if (store) {
+                  if (reasoningMessage === undefined) {
+                    input.push({ type: "item_reference", id: reasoningId });
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      summary: []
+                    };
+                  }
+                } else if (providerOptions?.reasoningEncryptedContent != null && reasoningMessage === undefined) {
+                  reasoningMessages[reasoningId] = {
+                    type: "reasoning",
+                    id: reasoningId,
+                    encrypted_content: providerOptions.reasoningEncryptedContent,
+                    summary: []
+                  };
+                  input.push(reasoningMessages[reasoningId]);
+                }
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`
+                });
+              }
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of content) {
+          if (part.type === "tool-approval-response") {
+            if (processedApprovalIds.has(part.approvalId)) {
+              continue;
+            }
+            processedApprovalIds.add(part.approvalId);
+            if (store) {
+              input.push({
+                type: "item_reference",
+                id: part.approvalId
+              });
+            }
+            input.push({
+              type: "mcp_approval_response",
+              approval_request_id: part.approvalId,
+              approve: part.approved
+            });
+            continue;
+          }
+          const output = part.output;
+          if (output.type === "execution-denied") {
+            const approvalId = output.providerOptions?.copilot?.approvalId;
+            if (approvalId) {
+              continue;
+            }
+          }
+          if (hasLocalShellTool && part.toolName === "local_shell" && output.type === "json") {
+            input.push({
+              type: "local_shell_call_output",
+              call_id: part.toolCallId,
+              output: localShellOutputSchema.parse(output.value).output
+            });
+            break;
+          }
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          input.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: contentValue
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { input, warnings };
+}
+var openaiResponsesReasoningProviderOptionsSchema = z.object({
+  itemId: z.string().nullish(),
+  reasoningEncryptedContent: z.string().nullish()
+});
+
+export { convertToOpenAIResponsesInput };