@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-6sc9h3ca.js

@@ -0,0 +1,116 @@
+import {
+  GET_VERSION_FOR,
+  MIGRATIONS_TABLE_VERSIONS
+} from "./permission-f84sxdqn.js";
+
+// src/database/drizzle/up-migrations/sqlite.ts
+import { sql } from "drizzle-orm/sql/sql";
+function unmatchedMigrationError(unmatched) {
+  return new Error(`While upgrading your database migrations table we found ${unmatched.length} (${unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(", ")}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`);
+}
+function prepareSQLiteMigrationBackfill(dbRows, localMigrations) {
+  const sortedLocalMigrations = [...localMigrations].sort((a, b) => a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? "").localeCompare(b.name ?? ""));
+  const byMillis = new Map;
+  const byHash = new Map;
+  for (const migration of sortedLocalMigrations) {
+    if (!byMillis.has(migration.folderMillis)) {
+      byMillis.set(migration.folderMillis, []);
+    }
+    byMillis.get(migration.folderMillis).push(migration);
+    byHash.set(migration.hash, migration);
+  }
+  const toApply = [];
+  const unmatched = [];
+  for (const dbRow of dbRows) {
+    const stringified = String(dbRow.created_at);
+    const millis = Number(stringified.substring(0, stringified.length - 3) + "000");
+    const candidates = byMillis.get(millis);
+    const matchedByMillis = candidates?.length === 1 ? candidates[0] : undefined;
+    const matchedByCandidateHash = candidates && candidates.length > 1 ? candidates.find((candidate) => candidate.hash && dbRow.hash && candidate.hash === dbRow.hash) : undefined;
+    const matchedByHash = matchedByMillis || matchedByCandidateHash ? undefined : byHash.get(dbRow.hash);
+    const matched = matchedByMillis ?? matchedByCandidateHash ?? matchedByHash;
+    if (matched) {
+      toApply.push({
+        name: matched.name,
+        selector: dbRow.id !== null ? { column: "id", value: dbRow.id } : matchedByMillis ? { column: "created_at", value: dbRow.created_at } : { column: "hash", value: dbRow.hash }
+      });
+      continue;
+    }
+    unmatched.push(dbRow);
+  }
+  if (unmatched.length > 0) {
+    throw unmatchedMigrationError(unmatched);
+  }
+  return toApply;
+}
+function buildSQLiteMigrationBackfillStatements(migrationsTable, backfillEntries) {
+  const table = sql`${sql.identifier(migrationsTable)}`;
+  const statements = [
+    sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier("name")} text`,
+    sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier("applied_at")} TEXT`
+  ];
+  for (const backfillEntry of backfillEntries) {
+    const updateQuery = sql`UPDATE ${table} SET ${sql.identifier("name")} = ${backfillEntry.name}, ${sql.identifier("applied_at")} = NULL WHERE`;
+    updateQuery.append(sql` ${sql.identifier(backfillEntry.selector.column)} = ${backfillEntry.selector.value}`);
+    statements.push(updateQuery);
+  }
+  return statements;
+}
+function upgradeSyncIfNeeded(migrationsTable, session, localMigrations) {
+  const tableExists = session.all(sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`);
+  if (tableExists.length === 0) {
+    return { newDb: true };
+  }
+  const rows = session.all(sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`);
+  const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+  for (let v = version;v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+    const upgradeFn = upgradeSyncFunctions[v];
+    if (!upgradeFn) {
+      throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+    }
+    upgradeFn(migrationsTable, session, localMigrations);
+  }
+  return { newDb: false };
+}
+var upgradeSyncFunctions = {
+  0: (migrationsTable, session, localMigrations) => {
+    const table = sql`${sql.identifier(migrationsTable)}`;
+    const dbRows = session.all(sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`);
+    const statements = buildSQLiteMigrationBackfillStatements(migrationsTable, prepareSQLiteMigrationBackfill(dbRows, localMigrations));
+    session.transaction((tx) => {
+      for (const statement of statements) {
+        tx.run(statement);
+      }
+    });
+  }
+};
+async function upgradeAsyncIfNeeded(migrationsTable, db, localMigrations) {
+  const tableExists = await db.session.all(sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`);
+  if (tableExists.length === 0) {
+    return { newDb: true };
+  }
+  const rows = await db.session.all(sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`);
+  const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+  for (let v = version;v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+    const upgradeFn = upgradeAsyncFunctions[v];
+    if (!upgradeFn) {
+      throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+    }
+    await upgradeFn(migrationsTable, db, localMigrations);
+  }
+  return { newDb: false };
+}
+var upgradeAsyncFunctions = {
+  0: async (migrationsTable, db, localMigrations) => {
+    const table = sql`${sql.identifier(migrationsTable)}`;
+    const dbRows = await db.session.all(sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`);
+    const statements = buildSQLiteMigrationBackfillStatements(migrationsTable, prepareSQLiteMigrationBackfill(dbRows, localMigrations));
+    await db.transaction(async (tx) => {
+      for (const statement of statements) {
+        await tx.run(statement);
+      }
+    });
+  }
+};
+
+export { prepareSQLiteMigrationBackfill, buildSQLiteMigrationBackfillStatements, upgradeSyncIfNeeded, upgradeAsyncIfNeeded };

package/dist/chunks/permission-6v88ksgf.js

@@ -0,0 +1,82 @@
+import {
+  exports_reference
+} from "./permission-anrqexna.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/reference/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  Service: () => Service,
+  ReferenceInstructions: () => exports_instructions2
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  name: Schema.String,
+  path: Schema.String,
+  description: Schema.String.pipe(Schema.optional)
+});
+var entries = (references) => references.flatMap((reference) => [
+  "  <reference>",
+  `    <name>${reference.name}</name>`,
+  `    <path>${reference.path}</path>`,
+  ...reference.description === undefined ? [] : [`    <description>${reference.description}</description>`],
+  "  </reference>"
+]);
+var render = (references) => [
+  "Project references provide additional directories that can be accessed when relevant.",
+  "<available_references>",
+  ...entries(references),
+  "</available_references>"
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = exports_instructions.diffByKey(previous, current, (reference) => reference.name, (before, after) => before.path !== after.path || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available project references have changed. This list supersedes the previous reference list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New project references are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following project references are no longer available and must not be used: ${diff.removed.map((reference) => reference.name).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/ReferenceInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const references = yield* exports_reference.Service;
+  return Service.of({
+    load: Effect.fn("ReferenceInstructions.load")(function* () {
+      const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
+        name: reference.name,
+        path: reference.path,
+        description: reference.description
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+      return exports_instructions.make({
+        key: exports_instructions.Key.make("core/reference-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Project reference guidance is no longer available. Do not use previously listed references."
+        }
+      });
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_reference.node] });
+
+export { Service, node, exports_instructions2 as exports_instructions };

package/dist/chunks/permission-6xc82ex6.js

@@ -0,0 +1,136 @@
+import {
+  exports_id
+} from "./permission-tcn24h1d.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool-output.ts
+var exports_tool_output = {};
+__export(exports_tool_output, {
+  node: () => node,
+  ToolOutput: () => exports_tool_output,
+  Service: () => Service,
+  RETENTION: () => RETENTION,
+  MAX_LINES: () => MAX_LINES,
+  MAX_BYTES: () => MAX_BYTES,
+  DIRECTORY: () => DIRECTORY
+});
+import path from "path";
+import { Context, Duration, Effect, Layer, Schedule } from "effect";
+import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+var MAX_LINES = 2000;
+var MAX_BYTES = 50 * 1024;
+var RETENTION = Duration.days(7);
+var DIRECTORY = "tool-output";
+
+class Service extends Context.Service()("@opencode/ToolOutput") {
+}
+var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
+  const cutoff = exports_id.timestamp(exports_id.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)));
+  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries2) => entries2.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.catch(() => Effect.succeed([])));
+  for (const entry of entries) {
+    if (exports_id.timestamp(entry) >= cutoff)
+      continue;
+    yield* fs.remove(path.join(directory, entry)).pipe(Effect.catch(() => Effect.void));
+  }
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY);
+  const truncate = Effect.fn("ToolOutput.truncate")(function* (result) {
+    if (result.metadata?.truncated !== undefined)
+      return result;
+    const content = typeof result.content === "string" ? [{ type: "text", text: result.content }] : result.content ?? [];
+    const text = content.flatMap((item) => item.type === "text" ? [item.text] : []).join(`
+`);
+    const configured = exports_config.latest(yield* config.entries(), "tool_output");
+    const maxLines = configured?.max_lines ?? MAX_LINES;
+    const maxBytes = configured?.max_bytes ?? MAX_BYTES;
+    const lines = text.split(`
+`);
+    if (text.endsWith(`
+`))
+      lines.pop();
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= maxLines && totalBytes <= maxBytes)
+      return { ...result, metadata: { ...result.metadata, truncated: false } };
+    const kept = [];
+    let bytes = 0;
+    let hitBytes = false;
+    for (const line of lines.slice(0, maxLines)) {
+      const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);
+      if (bytes + size > maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      kept.push(line);
+      bytes += size;
+    }
+    if (!hitBytes && kept.length === lines.length && totalBytes > bytes)
+      hitBytes = true;
+    const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length;
+    const unit = hitBytes ? removed === 1 ? "byte" : "bytes" : removed === 1 ? "line" : "lines";
+    const file = path.join(directory, exports_id.ascending("tool"));
+    yield* fs.ensureDir(directory).pipe(Effect.orDie);
+    yield* fs.writeFileString(file, text).pipe(Effect.orDie);
+    const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`;
+    const bounded = [];
+    let remaining = kept.join(`
+`).length;
+    let seenText = false;
+    let marked = false;
+    for (const item of content) {
+      if (item.type === "file") {
+        bounded.push(item);
+        continue;
+      }
+      if (seenText && remaining > 0)
+        remaining--;
+      seenText = true;
+      if (remaining >= item.text.length) {
+        bounded.push(item);
+        remaining -= item.text.length;
+        continue;
+      }
+      if (remaining > 0)
+        bounded.push({ ...item, text: item.text.slice(0, remaining) });
+      if (!marked)
+        bounded.push({ type: "text", text: marker });
+      remaining = 0;
+      marked = true;
+    }
+    if (!marked)
+      bounded.push({ type: "text", text: marker });
+    return {
+      ...result,
+      content: bounded,
+      metadata: { ...result.metadata, truncated: true, outputPath: file }
+    };
+  });
+  return Service.of({ truncate, cleanup: () => cleanup(fs, directory) });
+}));
+var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  yield* cleanup(fs, path.join(global.data, DIRECTORY)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+}));
+var cleanupNode = makeGlobalNode({
+  name: "tool-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, Global.node, cleanupNode]
+});
+
+export { MAX_LINES, MAX_BYTES, RETENTION, DIRECTORY, Service, node, exports_tool_output };

package/dist/chunks/permission-6yt963b8.js

@@ -0,0 +1,29 @@
+// src/database/migration/20260410174513_workspace-name.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260410174513_workspace-name",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`type\` text NOT NULL,
+          \`name\` text DEFAULT '' NOT NULL,
+          \`branch\` text,
+          \`directory\` text,
+          \`extra\` text,
+          \`project_id\` text NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_workspace\`(\`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\`) SELECT \`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\` FROM \`workspace\`;`);
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+    });
+  }
+};
+var _20260410174513_workspace_name_default = migration;
+
+export { _20260410174513_workspace_name_default };

package/dist/chunks/permission-706a4azd.js

@@ -0,0 +1,292 @@
+import {
+  which
+} from "./permission-g7k9te92.js";
+
+// src/formatter/builtins.ts
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make(input) {
+  const disabled = false;
+  const findExecutable = (name) => which(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 = {
+    name: "gofmt",
+    extensions: [".go"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("gofmt");
+      return match ? [match, "-w", "$FILE"] : disabled;
+    })
+  };
+  const mix = {
+    name: "mix",
+    extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("mix");
+      return match ? [match, "format", "$FILE"] : disabled;
+    })
+  };
+  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 = {
+    name: "zig",
+    extensions: [".zig", ".zon"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("zig");
+      return match ? [match, "fmt", "$FILE"] : disabled;
+    })
+  };
+  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 = {
+    name: "ktlint",
+    extensions: [".kt", ".kts"],
+    enabled: Effect.sync(() => {
+      const match = findExecutable("ktlint");
+      return match ? [match, "-F", "$FILE"] : disabled;
+    })
+  };
+  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 { make };