@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-19c2b9rb.js

@@ -0,0 +1,42 @@
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service10
+} from "./repository-jzksghxf.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/compaction.ts
+var exports_compaction = {};
+__export(exports_compaction, {
+  ConfigCompactionPlugin: () => exports_compaction,
+  Plugin: () => Plugin13
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin13 = define({
+  id: "opencode.config.compaction",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const compaction = yield* Service10;
+    const loaded = yield* observe2(config, ctx.event, compaction.reload());
+    yield* compaction.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document" || !entry.info.compaction)
+          continue;
+        editor.configure({
+          ...entry.info.compaction.auto === undefined ? {} : { auto: entry.info.compaction.auto },
+          ...entry.info.compaction.buffer === undefined ? {} : { buffer: entry.info.compaction.buffer },
+          ...entry.info.compaction.keep?.tokens === undefined ? {} : { tokens: entry.info.compaction.keep.tokens }
+        });
+      }
+    });
+  })
+});
+
+export { Plugin13, exports_compaction };

package/dist/chunks/repository-1bbkgx8g.js

@@ -0,0 +1,264 @@
+import {
+  which2
+} from "./repository-qaymkmh1.js";
+
+// src/formatter/builtins.ts
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make7(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 { make7 };

package/dist/chunks/repository-1bvekr7f.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/instance/service.ts
+var exports_service2 = {};
+__export(exports_service2, {
+  Instance: () => exports_service2,
+  Service: () => Service52,
+  node: () => node56
+});
+import { Context } from "effect";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+
+class Service52 extends Context.Service()("@opencode/Instance") {
+}
+var node56 = LayerNode.unbound(Service52, Node.tags.values.global);
+
+export { Service52, node56, exports_service2 };

package/dist/chunks/repository-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/repository-1dazxqgg.js

@@ -0,0 +1,154 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./repository-2a5m3afh.js";
+import {
+  __export
+} from "./repository-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 };