innocode 1.0.0

package/src/flag/flag.ts

@@ -0,0 +1,148 @@
+function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+// Support both INNOCODE_ and OPENCODE_ prefixes, with INNOCODE_ taking precedence
+function getEnv(innocodeKey: string, opencodeKey: string): string | undefined {
+  return process.env[innocodeKey] ?? process.env[opencodeKey]
+}
+
+function getTruthy(innocodeKey: string, opencodeKey: string): boolean {
+  return truthy(innocodeKey) || truthy(opencodeKey)
+}
+
+export namespace Flag {
+  export const INNOCODE_AUTO_SHARE = getTruthy("INNOCODE_AUTO_SHARE", "OPENCODE_AUTO_SHARE")
+  export const INNOCODE_GIT_BASH_PATH = getEnv("INNOCODE_GIT_BASH_PATH", "OPENCODE_GIT_BASH_PATH")
+  export const INNOCODE_CONFIG = getEnv("INNOCODE_CONFIG", "OPENCODE_CONFIG")
+  export declare const INNOCODE_CONFIG_DIR: string | undefined
+  export declare const OPENCODE_CONFIG_DIR: string | undefined
+  export const INNOCODE_CONFIG_CONTENT = getEnv("INNOCODE_CONFIG_CONTENT", "OPENCODE_CONFIG_CONTENT")
+  export const INNOCODE_DISABLE_AUTOUPDATE = getTruthy("INNOCODE_DISABLE_AUTOUPDATE", "OPENCODE_DISABLE_AUTOUPDATE")
+  export const INNOCODE_DISABLE_PRUNE = getTruthy("INNOCODE_DISABLE_PRUNE", "OPENCODE_DISABLE_PRUNE")
+  export const INNOCODE_DISABLE_TERMINAL_TITLE = getTruthy("INNOCODE_DISABLE_TERMINAL_TITLE", "OPENCODE_DISABLE_TERMINAL_TITLE")
+  export const INNOCODE_PERMISSION = getEnv("INNOCODE_PERMISSION", "OPENCODE_PERMISSION")
+  export const INNOCODE_DISABLE_DEFAULT_PLUGINS = getTruthy("INNOCODE_DISABLE_DEFAULT_PLUGINS", "OPENCODE_DISABLE_DEFAULT_PLUGINS")
+  export const INNOCODE_DISABLE_LSP_DOWNLOAD = getTruthy("INNOCODE_DISABLE_LSP_DOWNLOAD", "OPENCODE_DISABLE_LSP_DOWNLOAD")
+  export const INNOCODE_ENABLE_EXPERIMENTAL_MODELS = getTruthy("INNOCODE_ENABLE_EXPERIMENTAL_MODELS", "OPENCODE_ENABLE_EXPERIMENTAL_MODELS")
+  export const INNOCODE_DISABLE_AUTOCOMPACT = getTruthy("INNOCODE_DISABLE_AUTOCOMPACT", "OPENCODE_DISABLE_AUTOCOMPACT")
+  export const INNOCODE_DISABLE_MODELS_FETCH = getTruthy("INNOCODE_DISABLE_MODELS_FETCH", "OPENCODE_DISABLE_MODELS_FETCH")
+  export const INNOCODE_DISABLE_CLAUDE_CODE = getTruthy("INNOCODE_DISABLE_CLAUDE_CODE", "OPENCODE_DISABLE_CLAUDE_CODE")
+  export const INNOCODE_DISABLE_CLAUDE_CODE_PROMPT =
+    INNOCODE_DISABLE_CLAUDE_CODE || getTruthy("INNOCODE_DISABLE_CLAUDE_CODE_PROMPT", "OPENCODE_DISABLE_CLAUDE_CODE_PROMPT")
+  export const INNOCODE_DISABLE_CLAUDE_CODE_SKILLS =
+    INNOCODE_DISABLE_CLAUDE_CODE || getTruthy("INNOCODE_DISABLE_CLAUDE_CODE_SKILLS", "OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")
+  export const INNOCODE_DISABLE_EXTERNAL_SKILLS =
+    INNOCODE_DISABLE_CLAUDE_CODE_SKILLS || getTruthy("INNOCODE_DISABLE_EXTERNAL_SKILLS", "OPENCODE_DISABLE_EXTERNAL_SKILLS")
+  export declare const INNOCODE_DISABLE_PROJECT_CONFIG: boolean
+  export declare const OPENCODE_DISABLE_PROJECT_CONFIG: boolean
+  export const INNOCODE_FAKE_VCS = getEnv("INNOCODE_FAKE_VCS", "OPENCODE_FAKE_VCS")
+  export const INNOCODE_CLIENT = getEnv("INNOCODE_CLIENT", "OPENCODE_CLIENT") ?? "cli"
+  export const INNOCODE_SERVER_PASSWORD = getEnv("INNOCODE_SERVER_PASSWORD", "OPENCODE_SERVER_PASSWORD")
+  export const INNOCODE_SERVER_USERNAME = getEnv("INNOCODE_SERVER_USERNAME", "OPENCODE_SERVER_USERNAME")
+
+  // Experimental
+  export const INNOCODE_EXPERIMENTAL = getTruthy("INNOCODE_EXPERIMENTAL", "OPENCODE_EXPERIMENTAL")
+  export const INNOCODE_EXPERIMENTAL_FILEWATCHER = getTruthy("INNOCODE_EXPERIMENTAL_FILEWATCHER", "OPENCODE_EXPERIMENTAL_FILEWATCHER")
+  export const INNOCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = getTruthy("INNOCODE_EXPERIMENTAL_DISABLE_FILEWATCHER", "OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER")
+  export const INNOCODE_EXPERIMENTAL_ICON_DISCOVERY =
+    INNOCODE_EXPERIMENTAL || getTruthy("INNOCODE_EXPERIMENTAL_ICON_DISCOVERY", "OPENCODE_EXPERIMENTAL_ICON_DISCOVERY")
+  export const INNOCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = getTruthy("INNOCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT", "OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT")
+  export const INNOCODE_ENABLE_EXA =
+    getTruthy("INNOCODE_ENABLE_EXA", "OPENCODE_ENABLE_EXA") || INNOCODE_EXPERIMENTAL || getTruthy("INNOCODE_EXPERIMENTAL_EXA", "OPENCODE_EXPERIMENTAL_EXA")
+  export const INNOCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH = number("INNOCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH", "OPENCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH")
+  export const INNOCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("INNOCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS", "OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS")
+  export const INNOCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("INNOCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX", "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX")
+  export const INNOCODE_EXPERIMENTAL_OXFMT = INNOCODE_EXPERIMENTAL || getTruthy("INNOCODE_EXPERIMENTAL_OXFMT", "OPENCODE_EXPERIMENTAL_OXFMT")
+  export const INNOCODE_EXPERIMENTAL_LSP_TY = getTruthy("INNOCODE_EXPERIMENTAL_LSP_TY", "OPENCODE_EXPERIMENTAL_LSP_TY")
+  export const INNOCODE_EXPERIMENTAL_LSP_TOOL = INNOCODE_EXPERIMENTAL || getTruthy("INNOCODE_EXPERIMENTAL_LSP_TOOL", "OPENCODE_EXPERIMENTAL_LSP_TOOL")
+  export const INNOCODE_DISABLE_FILETIME_CHECK = getTruthy("INNOCODE_DISABLE_FILETIME_CHECK", "OPENCODE_DISABLE_FILETIME_CHECK")
+  export const INNOCODE_EXPERIMENTAL_PLAN_MODE = INNOCODE_EXPERIMENTAL || getTruthy("INNOCODE_EXPERIMENTAL_PLAN_MODE", "OPENCODE_EXPERIMENTAL_PLAN_MODE")
+  export const INNOCODE_EXPERIMENTAL_MARKDOWN = getTruthy("INNOCODE_EXPERIMENTAL_MARKDOWN", "OPENCODE_EXPERIMENTAL_MARKDOWN")
+  export const INNOCODE_MODELS_URL = getEnv("INNOCODE_MODELS_URL", "OPENCODE_MODELS_URL")
+  export const INNOCODE_MODELS_PATH = getEnv("INNOCODE_MODELS_PATH", "OPENCODE_MODELS_PATH")
+
+  // Legacy aliases (for backwards compatibility with OPENCODE_ prefix)
+  export const OPENCODE_AUTO_SHARE = INNOCODE_AUTO_SHARE
+  export const OPENCODE_GIT_BASH_PATH = INNOCODE_GIT_BASH_PATH
+  export const OPENCODE_CONFIG = INNOCODE_CONFIG
+  export const OPENCODE_CONFIG_CONTENT = INNOCODE_CONFIG_CONTENT
+  export const OPENCODE_DISABLE_AUTOUPDATE = INNOCODE_DISABLE_AUTOUPDATE
+  export const OPENCODE_DISABLE_PRUNE = INNOCODE_DISABLE_PRUNE
+  export const OPENCODE_DISABLE_TERMINAL_TITLE = INNOCODE_DISABLE_TERMINAL_TITLE
+  export const OPENCODE_PERMISSION = INNOCODE_PERMISSION
+  export const OPENCODE_DISABLE_DEFAULT_PLUGINS = INNOCODE_DISABLE_DEFAULT_PLUGINS
+  export const OPENCODE_DISABLE_LSP_DOWNLOAD = INNOCODE_DISABLE_LSP_DOWNLOAD
+  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = INNOCODE_ENABLE_EXPERIMENTAL_MODELS
+  export const OPENCODE_DISABLE_AUTOCOMPACT = INNOCODE_DISABLE_AUTOCOMPACT
+  export const OPENCODE_DISABLE_MODELS_FETCH = INNOCODE_DISABLE_MODELS_FETCH
+  export const OPENCODE_DISABLE_CLAUDE_CODE = INNOCODE_DISABLE_CLAUDE_CODE
+  export const OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = INNOCODE_DISABLE_CLAUDE_CODE_PROMPT
+  export const OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = INNOCODE_DISABLE_CLAUDE_CODE_SKILLS
+  export const OPENCODE_DISABLE_EXTERNAL_SKILLS = INNOCODE_DISABLE_EXTERNAL_SKILLS
+  export const OPENCODE_FAKE_VCS = INNOCODE_FAKE_VCS
+  export const OPENCODE_CLIENT = INNOCODE_CLIENT
+  export const OPENCODE_SERVER_PASSWORD = INNOCODE_SERVER_PASSWORD
+  export const OPENCODE_SERVER_USERNAME = INNOCODE_SERVER_USERNAME
+  export const OPENCODE_EXPERIMENTAL = INNOCODE_EXPERIMENTAL
+  export const OPENCODE_EXPERIMENTAL_FILEWATCHER = INNOCODE_EXPERIMENTAL_FILEWATCHER
+  export const OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = INNOCODE_EXPERIMENTAL_DISABLE_FILEWATCHER
+  export const OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = INNOCODE_EXPERIMENTAL_ICON_DISCOVERY
+  export const OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = INNOCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT
+  export const OPENCODE_ENABLE_EXA = INNOCODE_ENABLE_EXA
+  export const OPENCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH = INNOCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH
+  export const OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = INNOCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS
+  export const OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = INNOCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX
+  export const OPENCODE_EXPERIMENTAL_OXFMT = INNOCODE_EXPERIMENTAL_OXFMT
+  export const OPENCODE_EXPERIMENTAL_LSP_TY = INNOCODE_EXPERIMENTAL_LSP_TY
+  export const OPENCODE_EXPERIMENTAL_LSP_TOOL = INNOCODE_EXPERIMENTAL_LSP_TOOL
+  export const OPENCODE_DISABLE_FILETIME_CHECK = INNOCODE_DISABLE_FILETIME_CHECK
+  export const OPENCODE_EXPERIMENTAL_PLAN_MODE = INNOCODE_EXPERIMENTAL_PLAN_MODE
+  export const OPENCODE_EXPERIMENTAL_MARKDOWN = INNOCODE_EXPERIMENTAL_MARKDOWN
+  export const OPENCODE_MODELS_URL = INNOCODE_MODELS_URL
+  export const OPENCODE_MODELS_PATH = INNOCODE_MODELS_PATH
+
+  function number(innocodeKey: string, opencodeKey: string) {
+    const value = getEnv(innocodeKey, opencodeKey)
+    if (!value) return undefined
+    const parsed = Number(value)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+  }
+}
+
+// Dynamic getter for INNOCODE_DISABLE_PROJECT_CONFIG
+Object.defineProperty(Flag, "INNOCODE_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("INNOCODE_DISABLE_PROJECT_CONFIG") || truthy("OPENCODE_DISABLE_PROJECT_CONFIG")
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Legacy alias
+Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return (Flag as any).INNOCODE_DISABLE_PROJECT_CONFIG
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for INNOCODE_CONFIG_DIR
+Object.defineProperty(Flag, "INNOCODE_CONFIG_DIR", {
+  get() {
+    return process.env["INNOCODE_CONFIG_DIR"] ?? process.env["OPENCODE_CONFIG_DIR"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Legacy alias
+Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
+  get() {
+    return (Flag as any).INNOCODE_CONFIG_DIR
+  },
+  enumerable: true,
+  configurable: false,
+})

package/src/format/formatter.ts

@@ -0,0 +1,366 @@
+import { readableStreamToText } from "bun"
+import { BunProc } from "../bun"
+import { Instance } from "../project/instance"
+import { Filesystem } from "../util/filesystem"
+import { Flag } from "@/flag/flag"
+
+export interface Info {
+  name: string
+  command: string[]
+  environment?: Record<string, string>
+  extensions: string[]
+  enabled(): Promise<boolean>
+}
+
+export const gofmt: Info = {
+  name: "gofmt",
+  command: ["gofmt", "-w", "$FILE"],
+  extensions: [".go"],
+  async enabled() {
+    return Bun.which("gofmt") !== null
+  },
+}
+
+export const mix: Info = {
+  name: "mix",
+  command: ["mix", "format", "$FILE"],
+  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+  async enabled() {
+    return Bun.which("mix") !== null
+  },
+}
+
+export const prettier: Info = {
+  name: "prettier",
+  command: [BunProc.which(), "x", "prettier", "--write", "$FILE"],
+  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",
+  ],
+  async enabled() {
+    const items = await Filesystem.findUp("package.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.dependencies?.prettier) return true
+      if (json.devDependencies?.prettier) return true
+    }
+    return false
+  },
+}
+
+export const oxfmt: Info = {
+  name: "oxfmt",
+  command: [BunProc.which(), "x", "oxfmt", "$FILE"],
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+  async enabled() {
+    if (!Flag.OPENCODE_EXPERIMENTAL_OXFMT) return false
+    const items = await Filesystem.findUp("package.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.dependencies?.oxfmt) return true
+      if (json.devDependencies?.oxfmt) return true
+    }
+    return false
+  },
+}
+
+export const biome: Info = {
+  name: "biome",
+  command: [BunProc.which(), "x", "@biomejs/biome", "check", "--write", "$FILE"],
+  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",
+  ],
+  async enabled() {
+    const configs = ["biome.json", "biome.jsonc"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        return true
+      }
+    }
+    return false
+  },
+}
+
+export const zig: Info = {
+  name: "zig",
+  command: ["zig", "fmt", "$FILE"],
+  extensions: [".zig", ".zon"],
+  async enabled() {
+    return Bun.which("zig") !== null
+  },
+}
+
+export const clang: Info = {
+  name: "clang-format",
+  command: ["clang-format", "-i", "$FILE"],
+  extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+  async enabled() {
+    const items = await Filesystem.findUp(".clang-format", Instance.directory, Instance.worktree)
+    return items.length > 0
+  },
+}
+
+export const ktlint: Info = {
+  name: "ktlint",
+  command: ["ktlint", "-F", "$FILE"],
+  extensions: [".kt", ".kts"],
+  async enabled() {
+    return Bun.which("ktlint") !== null
+  },
+}
+
+export const ruff: Info = {
+  name: "ruff",
+  command: ["ruff", "format", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async enabled() {
+    if (!Bun.which("ruff")) return false
+    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        if (config === "pyproject.toml") {
+          const content = await Bun.file(found[0]).text()
+          if (content.includes("[tool.ruff]")) return true
+        } else {
+          return true
+        }
+      }
+    }
+    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    for (const dep of deps) {
+      const found = await Filesystem.findUp(dep, Instance.directory, Instance.worktree)
+      if (found.length > 0) {
+        const content = await Bun.file(found[0]).text()
+        if (content.includes("ruff")) return true
+      }
+    }
+    return false
+  },
+}
+
+export const rlang: Info = {
+  name: "air",
+  command: ["air", "format", "$FILE"],
+  extensions: [".R"],
+  async enabled() {
+    const airPath = Bun.which("air")
+    if (airPath == null) return false
+
+    try {
+      const proc = Bun.spawn(["air", "--help"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+      await proc.exited
+      const output = await readableStreamToText(proc.stdout)
+
+      // Check for "Air: An R language server and formatter"
+      const firstLine = output.split("\n")[0]
+      const hasR = firstLine.includes("R language")
+      const hasFormatter = firstLine.includes("formatter")
+      return hasR && hasFormatter
+    } catch (error) {
+      return false
+    }
+  },
+}
+
+export const uvformat: Info = {
+  name: "uv",
+  command: ["uv", "format", "--", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async enabled() {
+    if (await ruff.enabled()) return false
+    if (Bun.which("uv") !== null) {
+      const proc = Bun.spawn(["uv", "format", "--help"], { stderr: "pipe", stdout: "pipe" })
+      const code = await proc.exited
+      return code === 0
+    }
+    return false
+  },
+}
+
+export const rubocop: Info = {
+  name: "rubocop",
+  command: ["rubocop", "--autocorrect", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("rubocop") !== null
+  },
+}
+
+export const standardrb: Info = {
+  name: "standardrb",
+  command: ["standardrb", "--fix", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("standardrb") !== null
+  },
+}
+
+export const htmlbeautifier: Info = {
+  name: "htmlbeautifier",
+  command: ["htmlbeautifier", "$FILE"],
+  extensions: [".erb", ".html.erb"],
+  async enabled() {
+    return Bun.which("htmlbeautifier") !== null
+  },
+}
+
+export const dart: Info = {
+  name: "dart",
+  command: ["dart", "format", "$FILE"],
+  extensions: [".dart"],
+  async enabled() {
+    return Bun.which("dart") !== null
+  },
+}
+
+export const ocamlformat: Info = {
+  name: "ocamlformat",
+  command: ["ocamlformat", "-i", "$FILE"],
+  extensions: [".ml", ".mli"],
+  async enabled() {
+    if (!Bun.which("ocamlformat")) return false
+    const items = await Filesystem.findUp(".ocamlformat", Instance.directory, Instance.worktree)
+    return items.length > 0
+  },
+}
+
+export const terraform: Info = {
+  name: "terraform",
+  command: ["terraform", "fmt", "$FILE"],
+  extensions: [".tf", ".tfvars"],
+  async enabled() {
+    return Bun.which("terraform") !== null
+  },
+}
+
+export const latexindent: Info = {
+  name: "latexindent",
+  command: ["latexindent", "-w", "-s", "$FILE"],
+  extensions: [".tex"],
+  async enabled() {
+    return Bun.which("latexindent") !== null
+  },
+}
+
+export const gleam: Info = {
+  name: "gleam",
+  command: ["gleam", "format", "$FILE"],
+  extensions: [".gleam"],
+  async enabled() {
+    return Bun.which("gleam") !== null
+  },
+}
+
+export const shfmt: Info = {
+  name: "shfmt",
+  command: ["shfmt", "-w", "$FILE"],
+  extensions: [".sh", ".bash"],
+  async enabled() {
+    return Bun.which("shfmt") !== null
+  },
+}
+
+export const nixfmt: Info = {
+  name: "nixfmt",
+  command: ["nixfmt", "$FILE"],
+  extensions: [".nix"],
+  async enabled() {
+    return Bun.which("nixfmt") !== null
+  },
+}
+
+export const rustfmt: Info = {
+  name: "rustfmt",
+  command: ["rustfmt", "$FILE"],
+  extensions: [".rs"],
+  async enabled() {
+    return Bun.which("rustfmt") !== null
+  },
+}
+
+export const pint: Info = {
+  name: "pint",
+  command: ["./vendor/bin/pint", "$FILE"],
+  extensions: [".php"],
+  async enabled() {
+    const items = await Filesystem.findUp("composer.json", Instance.directory, Instance.worktree)
+    for (const item of items) {
+      const json = await Bun.file(item).json()
+      if (json.require?.["laravel/pint"]) return true
+      if (json["require-dev"]?.["laravel/pint"]) return true
+    }
+    return false
+  },
+}
+
+export const ormolu: Info = {
+  name: "ormolu",
+  command: ["ormolu", "-i", "$FILE"],
+  extensions: [".hs"],
+  async enabled() {
+    return Bun.which("ormolu") !== null
+  },
+}

package/src/format/index.ts

@@ -0,0 +1,137 @@
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Log } from "../util/log"
+import path from "path"
+import z from "zod"
+
+import * as Formatter from "./formatter"
+import { Config } from "../config/config"
+import { mergeDeep } from "remeda"
+import { Instance } from "../project/instance"
+
+export namespace Format {
+  const log = Log.create({ service: "format" })
+
+  export const Status = z
+    .object({
+      name: z.string(),
+      extensions: z.string().array(),
+      enabled: z.boolean(),
+    })
+    .meta({
+      ref: "FormatterStatus",
+    })
+  export type Status = z.infer<typeof Status>
+
+  const state = Instance.state(async () => {
+    const enabled: Record<string, boolean> = {}
+    const cfg = await Config.get()
+
+    const formatters: Record<string, Formatter.Info> = {}
+    if (cfg.formatter === false) {
+      log.info("all formatters are disabled")
+      return {
+        enabled,
+        formatters,
+      }
+    }
+
+    for (const item of Object.values(Formatter)) {
+      formatters[item.name] = item
+    }
+    for (const [name, item] of Object.entries(cfg.formatter ?? {})) {
+      if (item.disabled) {
+        delete formatters[name]
+        continue
+      }
+      const result: Formatter.Info = mergeDeep(formatters[name] ?? {}, {
+        command: [],
+        extensions: [],
+        ...item,
+      })
+
+      if (result.command.length === 0) continue
+
+      result.enabled = async () => true
+      result.name = name
+      formatters[name] = result
+    }
+
+    return {
+      enabled,
+      formatters,
+    }
+  })
+
+  async function isEnabled(item: Formatter.Info) {
+    const s = await state()
+    let status = s.enabled[item.name]
+    if (status === undefined) {
+      status = await item.enabled()
+      s.enabled[item.name] = status
+    }
+    return status
+  }
+
+  async function getFormatter(ext: string) {
+    const formatters = await state().then((x) => x.formatters)
+    const result = []
+    for (const item of Object.values(formatters)) {
+      log.info("checking", { name: item.name, ext })
+      if (!item.extensions.includes(ext)) continue
+      if (!(await isEnabled(item))) continue
+      log.info("enabled", { name: item.name, ext })
+      result.push(item)
+    }
+    return result
+  }
+
+  export async function status() {
+    const s = await state()
+    const result: Status[] = []
+    for (const formatter of Object.values(s.formatters)) {
+      const enabled = await isEnabled(formatter)
+      result.push({
+        name: formatter.name,
+        extensions: formatter.extensions,
+        enabled,
+      })
+    }
+    return result
+  }
+
+  export function init() {
+    log.info("init")
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const file = payload.properties.file
+      log.info("formatting", { file })
+      const ext = path.extname(file)
+
+      for (const item of await getFormatter(ext)) {
+        log.info("running", { command: item.command })
+        try {
+          const proc = Bun.spawn({
+            cmd: item.command.map((x) => x.replace("$FILE", file)),
+            cwd: Instance.directory,
+            env: { ...process.env, ...item.environment },
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          const exit = await proc.exited
+          if (exit !== 0)
+            log.error("failed", {
+              command: item.command,
+              ...item.environment,
+            })
+        } catch (error) {
+          log.error("failed to format file", {
+            error,
+            command: item.command,
+            ...item.environment,
+            file,
+          })
+        }
+      }
+    })
+  }
+}