@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-mvfsc1pv.js

@@ -0,0 +1,264 @@
+import {
+  which2
+} from "./worktree-qaymkmh1.js";
+
+// src/formatter/builtins.ts
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make4(input) {
+  const disabled = false;
+  const findExecutable = (name) => which2(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 = executable("gofmt", [".go"], ["-w", "$FILE"], findExecutable);
+  const mix = executable("mix", [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"], ["format", "$FILE"], findExecutable);
+  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 = executable("zig", [".zig", ".zon"], ["fmt", "$FILE"], findExecutable);
+  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 = executable("ktlint", [".kt", ".kts"], ["-F", "$FILE"], findExecutable);
+  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 { make4 };

package/dist/chunks/worktree-n05xt0ee.js

@@ -0,0 +1,19 @@
+// src/database/migration/20260622202450_simplify_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622202450_simplify_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+    });
+  }
+};
+var _20260622202450_simplify_session_input_default = migration;
+
+export { _20260622202450_simplify_session_input_default };

package/dist/chunks/worktree-n1s6t8b2.js

@@ -0,0 +1,191 @@
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  addPatch2,
+  deletePatch2,
+  countPatch2,
+  chunksByFile2
+} from "./worktree-tazgh4e4.js";
+import {
+  DiffError2
+} from "./worktree-vp47j2z8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/vcs/hg.ts
+var exports_hg = {};
+__export(exports_hg, {
+  Plugin: () => Plugin33,
+  VcsHgPlugin: () => exports_hg
+});
+import path from "path";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { define } from "@opencode/plugin/effect/plugin";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+var Plugin33 = define({
+  id: "opencode.vcs.hg",
+  effect: Effect.fn("VcsHgPlugin")(function* (ctx) {
+    const location = yield* Service74;
+    if (location.vcs?.type !== "hg")
+      return;
+    const processes = yield* AppProcess.Service;
+    const fs = yield* FSUtil.Service;
+    const adapter = make(processes, fs, {
+      directory: location.directory,
+      worktree: location.project.directory
+    });
+    yield* ctx.vcs.transform((editor) => {
+      editor.add({
+        id: "hg",
+        name: "Mercurial",
+        info: () => adapter.info(),
+        branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
+        status: () => adapter.status(),
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
+      });
+    });
+  })
+});
+function make(proc, fs, input) {
+  const hg = makeHg(proc, input.worktree);
+  const scope = path.relative(input.worktree, input.directory) || ".";
+  const patchFor = Effect.fnUntraced(function* (item, rev, chunk) {
+    if (chunk !== undefined)
+      return chunk;
+    if (item.code === "?") {
+      const content = yield* fs.readFileString(path.join(input.worktree, item.file)).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return addPatch2(item.file, content);
+    }
+    if (item.code === "!") {
+      const content = yield* hg.cat(rev ?? ".", item.file);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return deletePatch2(item.file, content);
+    }
+    return emptyPatch2(item.file);
+  });
+  const diffAgainst = Effect.fnUntraced(function* (rev, options) {
+    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES2 })], { concurrency: 2 });
+    const chunks = chunksByFile2(batch, () => {
+      return;
+    });
+    const list = [];
+    for (const item of items.toSorted((a, b) => a.file.localeCompare(b.file))) {
+      const patch = yield* patchFor(item, rev, chunks.get(item.file));
+      const counts = countPatch2(patch);
+      list.push({
+        file: item.file,
+        patch,
+        additions: counts.additions,
+        deletions: counts.deletions,
+        status: item.status
+      });
+    }
+    return list;
+  });
+  return {
+    info: Effect.fn("VcsHg.info")(function* () {
+      return { branch: { current: yield* hg.branch(), default: "default" } };
+    }),
+    branches: Effect.fn("VcsHg.branches")(function* () {
+      return [];
+    }),
+    status: Effect.fn("VcsHg.status")(function* () {
+      return (yield* diffAgainst(undefined, { context: 0 })).map((item) => ({
+        file: item.file,
+        additions: item.additions,
+        deletions: item.deletions,
+        status: item.status
+      }));
+    }),
+    diff: Effect.fn("VcsHg.diff")(function* (mode, options) {
+      if (mode === "working")
+        return yield* diffAgainst(undefined, options);
+      if (mode === "committed" || options?.base !== undefined) {
+        return yield* new DiffError2({
+          message: "The Mercurial provider does not support committed reviews or explicit bases"
+        });
+      }
+      const branch = yield* hg.branch();
+      if (!branch || branch === "default")
+        return [];
+      const ancestor = yield* hg.ancestor();
+      if (!ancestor)
+        return [];
+      return yield* diffAgainst(ancestor, options);
+    })
+  };
+}
+var kind = (code) => {
+  if (code === "A" || code === "?")
+    return "added";
+  if (code === "R" || code === "!")
+    return "deleted";
+  return "modified";
+};
+function makeHg(proc, worktree) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("hg", args, {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts?.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.orElseSucceed(() => ({ exitCode: 1, text: () => "", truncated: false })));
+  const status = Effect.fn("VcsHg.statusNames")(function* (rev, scope) {
+    const result = yield* run(["status", "-0", ...rev ? ["--rev", rev] : [], scope]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text().split("\x00").filter(Boolean).flatMap((entry) => {
+      const code = entry.slice(0, 1);
+      const file = entry.slice(2);
+      if (!file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsHg.diffPatch")(function* (rev, scope, options) {
+    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES2 });
+    if (result.exitCode !== 0)
+      return { text: "", truncated: false };
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const branch = Effect.fn("VcsHg.branch")(function* () {
+    const result = yield* run(["branch"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fn("VcsHg.ancestor")(function* () {
+    const result = yield* run(["log", "-r", "ancestor(., default)", "-T", "{node}"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const cat = Effect.fn("VcsHg.cat")(function* (rev, file) {
+    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES2 });
+    if (result.exitCode !== 0 || result.truncated)
+      return;
+    return result.text();
+  });
+  return { status, diff, branch, ancestor, cat };
+}
+
+export { Plugin33, exports_hg };

package/dist/chunks/worktree-n3j8tn72.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260428004200_add_session_path.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260428004200_add_session_path",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`);
+    });
+  }
+};
+var _20260428004200_add_session_path_default = migration;
+
+export { _20260428004200_add_session_path_default };