@toolkit-cli/toolkode 1.3.8 → 1.3.10

package/src/format/formatter.ts

@@ -1,396 +0,0 @@
-import { text } from "node:stream/consumers"
-import { BunProc } from "../bun"
-import { Instance } from "../project/instance"
-import { Filesystem } from "../util/filesystem"
-import { Process } from "../util/process"
-import { which } from "../util/which"
-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 which("gofmt") !== null
-  },
-}
-
-export const mix: Info = {
-  name: "mix",
-  command: ["mix", "format", "$FILE"],
-  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
-  async enabled() {
-    return 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 Filesystem.readJson<{
-        dependencies?: Record<string, string>
-        devDependencies?: Record<string, string>
-      }>(item)
-      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 Filesystem.readJson<{
-        dependencies?: Record<string, string>
-        devDependencies?: Record<string, string>
-      }>(item)
-      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 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 which("ktlint") !== null
-  },
-}
-
-export const ruff: Info = {
-  name: "ruff",
-  command: ["ruff", "format", "$FILE"],
-  extensions: [".py", ".pyi"],
-  async enabled() {
-    if (!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 Filesystem.readText(found[0])
-          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 Filesystem.readText(found[0])
-        if (content.includes("ruff")) return true
-      }
-    }
-    return false
-  },
-}
-
-export const rlang: Info = {
-  name: "air",
-  command: ["air", "format", "$FILE"],
-  extensions: [".R"],
-  async enabled() {
-    const airPath = which("air")
-    if (airPath == null) return false
-
-    try {
-      const proc = Process.spawn(["air", "--help"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      })
-      await proc.exited
-      if (!proc.stdout) return false
-      const output = await text(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 (which("uv") !== null) {
-      const proc = Process.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 which("rubocop") !== null
-  },
-}
-
-export const standardrb: Info = {
-  name: "standardrb",
-  command: ["standardrb", "--fix", "$FILE"],
-  extensions: [".rb", ".rake", ".gemspec", ".ru"],
-  async enabled() {
-    return which("standardrb") !== null
-  },
-}
-
-export const htmlbeautifier: Info = {
-  name: "htmlbeautifier",
-  command: ["htmlbeautifier", "$FILE"],
-  extensions: [".erb", ".html.erb"],
-  async enabled() {
-    return which("htmlbeautifier") !== null
-  },
-}
-
-export const dart: Info = {
-  name: "dart",
-  command: ["dart", "format", "$FILE"],
-  extensions: [".dart"],
-  async enabled() {
-    return which("dart") !== null
-  },
-}
-
-export const ocamlformat: Info = {
-  name: "ocamlformat",
-  command: ["ocamlformat", "-i", "$FILE"],
-  extensions: [".ml", ".mli"],
-  async enabled() {
-    if (!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 which("terraform") !== null
-  },
-}
-
-export const latexindent: Info = {
-  name: "latexindent",
-  command: ["latexindent", "-w", "-s", "$FILE"],
-  extensions: [".tex"],
-  async enabled() {
-    return which("latexindent") !== null
-  },
-}
-
-export const gleam: Info = {
-  name: "gleam",
-  command: ["gleam", "format", "$FILE"],
-  extensions: [".gleam"],
-  async enabled() {
-    return which("gleam") !== null
-  },
-}
-
-export const shfmt: Info = {
-  name: "shfmt",
-  command: ["shfmt", "-w", "$FILE"],
-  extensions: [".sh", ".bash"],
-  async enabled() {
-    return which("shfmt") !== null
-  },
-}
-
-export const nixfmt: Info = {
-  name: "nixfmt",
-  command: ["nixfmt", "$FILE"],
-  extensions: [".nix"],
-  async enabled() {
-    return which("nixfmt") !== null
-  },
-}
-
-export const rustfmt: Info = {
-  name: "rustfmt",
-  command: ["rustfmt", "$FILE"],
-  extensions: [".rs"],
-  async enabled() {
-    return 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 Filesystem.readJson<{
-        require?: Record<string, string>
-        "require-dev"?: Record<string, string>
-      }>(item)
-      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 which("ormolu") !== null
-  },
-}
-
-export const cljfmt: Info = {
-  name: "cljfmt",
-  command: ["cljfmt", "fix", "--quiet", "$FILE"],
-  extensions: [".clj", ".cljs", ".cljc", ".edn"],
-  async enabled() {
-    return which("cljfmt") !== null
-  },
-}
-
-export const dfmt: Info = {
-  name: "dfmt",
-  command: ["dfmt", "-i", "$FILE"],
-  extensions: [".d"],
-  async enabled() {
-    return which("dfmt") !== null
-  },
-}

package/src/format/index.ts

@@ -1,199 +0,0 @@
-import { Effect, Layer, ServiceMap } from "effect"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-import path from "path"
-import { mergeDeep } from "remeda"
-import z from "zod"
-import { Config } from "../config/config"
-import { Instance } from "../project/instance"
-import { Log } from "../util/log"
-import * as Formatter from "./formatter"
-
-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>
-
-  export interface Interface {
-    readonly init: () => Effect.Effect<void>
-    readonly status: () => Effect.Effect<Status[]>
-    readonly file: (filepath: string) => Effect.Effect<void>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Format") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-
-      const state = yield* InstanceState.make(
-        Effect.fn("Format.state")(function* (_ctx) {
-          const enabled: Record<string, boolean> = {}
-          const formatters: Record<string, Formatter.Info> = {}
-
-          const cfg = yield* config.get()
-
-          if (cfg.formatter !== false) {
-            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 info = mergeDeep(formatters[name] ?? {}, {
-                command: [],
-                extensions: [],
-                ...item,
-              })
-
-              if (info.command.length === 0) continue
-
-              formatters[name] = {
-                ...info,
-                name,
-                enabled: async () => true,
-              }
-            }
-          } else {
-            log.info("all formatters are disabled")
-          }
-
-          async function isEnabled(item: Formatter.Info) {
-            let status = enabled[item.name]
-            if (status === undefined) {
-              status = await item.enabled()
-              enabled[item.name] = status
-            }
-            return status
-          }
-
-          async function getFormatter(ext: string) {
-            const matching = Object.values(formatters).filter((item) => item.extensions.includes(ext))
-            const checks = await Promise.all(
-              matching.map(async (item) => {
-                log.info("checking", { name: item.name, ext })
-                const on = await isEnabled(item)
-                if (on) {
-                  log.info("enabled", { name: item.name, ext })
-                }
-                return {
-                  item,
-                  enabled: on,
-                }
-              }),
-            )
-            return checks.filter((x) => x.enabled).map((x) => x.item)
-          }
-
-          function formatFile(filepath: string) {
-            return Effect.gen(function* () {
-              log.info("formatting", { file: filepath })
-              const ext = path.extname(filepath)
-
-              for (const item of yield* Effect.promise(() => getFormatter(ext))) {
-                log.info("running", { command: item.command })
-                const cmd = item.command.map((x) => x.replace("$FILE", filepath))
-                const code = yield* spawner
-                  .spawn(
-                    ChildProcess.make(cmd[0]!, cmd.slice(1), {
-                      cwd: Instance.directory,
-                      env: item.environment,
-                      extendEnv: true,
-                    }),
-                  )
-                  .pipe(
-                    Effect.flatMap((handle) => handle.exitCode),
-                    Effect.scoped,
-                    Effect.catch(() =>
-                      Effect.sync(() => {
-                        log.error("failed to format file", {
-                          error: "spawn failed",
-                          command: item.command,
-                          ...item.environment,
-                          file: filepath,
-                        })
-                        return ChildProcessSpawner.ExitCode(1)
-                      }),
-                    ),
-                  )
-                if (code !== 0) {
-                  log.error("failed", {
-                    command: item.command,
-                    ...item.environment,
-                  })
-                }
-              }
-            })
-          }
-
-          log.info("init")
-
-          return {
-            formatters,
-            isEnabled,
-            formatFile,
-          }
-        }),
-      )
-
-      const init = Effect.fn("Format.init")(function* () {
-        yield* InstanceState.get(state)
-      })
-
-      const status = Effect.fn("Format.status")(function* () {
-        const { formatters, isEnabled } = yield* InstanceState.get(state)
-        const result: Status[] = []
-        for (const formatter of Object.values(formatters)) {
-          const isOn = yield* Effect.promise(() => isEnabled(formatter))
-          result.push({
-            name: formatter.name,
-            extensions: formatter.extensions,
-            enabled: isOn,
-          })
-        }
-        return result
-      })
-
-      const file = Effect.fn("Format.file")(function* (filepath: string) {
-        const { formatFile } = yield* InstanceState.get(state)
-        yield* formatFile(filepath)
-      })
-
-      return Service.of({ init, status, file })
-    }),
-  )
-
-  export const defaultLayer = layer.pipe(
-    Layer.provide(Config.defaultLayer),
-    Layer.provide(CrossSpawnSpawner.defaultLayer),
-  )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function init() {
-    return runPromise((s) => s.init())
-  }
-
-  export async function status() {
-    return runPromise((s) => s.status())
-  }
-
-  export async function file(filepath: string) {
-    return runPromise((s) => s.file(filepath))
-  }
-}

package/src/global/index.ts

@@ -1,54 +0,0 @@
-import fs from "fs/promises"
-import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
-import path from "path"
-import os from "os"
-import { Filesystem } from "../util/filesystem"
-
-const app = "toolkode"
-
-const data = path.join(xdgData!, app)
-const cache = path.join(xdgCache!, app)
-const config = path.join(xdgConfig!, app)
-const state = path.join(xdgState!, app)
-
-export namespace Global {
-  export const Path = {
-    // Allow override via OPENCODE_TEST_HOME for test isolation
-    get home() {
-      return process.env.OPENCODE_TEST_HOME || os.homedir()
-    },
-    data,
-    bin: path.join(cache, "bin"),
-    log: path.join(data, "log"),
-    cache,
-    config,
-    state,
-  }
-}
-
-await Promise.all([
-  fs.mkdir(Global.Path.data, { recursive: true }),
-  fs.mkdir(Global.Path.config, { recursive: true }),
-  fs.mkdir(Global.Path.state, { recursive: true }),
-  fs.mkdir(Global.Path.log, { recursive: true }),
-  fs.mkdir(Global.Path.bin, { recursive: true }),
-])
-
-const CACHE_VERSION = "21"
-
-const version = await Filesystem.readText(path.join(Global.Path.cache, "version")).catch(() => "0")
-
-if (version !== CACHE_VERSION) {
-  try {
-    const contents = await fs.readdir(Global.Path.cache)
-    await Promise.all(
-      contents.map((item) =>
-        fs.rm(path.join(Global.Path.cache, item), {
-          recursive: true,
-          force: true,
-        }),
-      ),
-    )
-  } catch (e) {}
-  await Filesystem.write(path.join(Global.Path.cache, "version"), CACHE_VERSION)
-}