easc-cli 1.1.37 → 1.1.40

package/src/format/formatter.ts

@@ -1,342 +0,0 @@
-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
-  },
-}

package/src/format/index.ts

@@ -1,137 +0,0 @@
-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,
-          })
-        }
-      }
-    })
-  }
-}

package/src/global/index.ts

@@ -1,55 +0,0 @@
-import fs from "fs/promises"
-import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
-import path from "path"
-import os from "os"
-
-const app = "easc"
-
-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(data, "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 = "18"
-
-const version = await Bun.file(path.join(Global.Path.cache, "version"))
-  .text()
-  .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 Bun.file(path.join(Global.Path.cache, "version")).write(CACHE_VERSION)
-}

package/src/id/id.ts

@@ -1,83 +0,0 @@
-import z from "zod"
-import { randomBytes } from "crypto"
-
-export namespace Identifier {
-  const prefixes = {
-    session: "ses",
-    message: "msg",
-    permission: "per",
-    question: "que",
-    user: "usr",
-    part: "prt",
-    pty: "pty",
-    tool: "tool",
-  } as const
-
-  export function schema(prefix: keyof typeof prefixes) {
-    return z.string().startsWith(prefixes[prefix])
-  }
-
-  const LENGTH = 26
-
-  // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
-
-  export function ascending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, false, given)
-  }
-
-  export function descending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, true, given)
-  }
-
-  function generateID(prefix: keyof typeof prefixes, descending: boolean, given?: string): string {
-    if (!given) {
-      return create(prefix, descending)
-    }
-
-    if (!given.startsWith(prefixes[prefix])) {
-      throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
-    }
-    return given
-  }
-
-  function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
-    for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
-    }
-    return result
-  }
-
-  export function create(prefix: keyof typeof prefixes, descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
-
-    if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
-    }
-    counter++
-
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-    now = descending ? ~now : now
-
-    const timeBytes = Buffer.alloc(6)
-    for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-    }
-
-    return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-  }
-
-  /** Extract timestamp from an ascending ID. Does not work with descending IDs. */
-  export function timestamp(id: string): number {
-    const prefix = id.split("_")[0]
-    const hex = id.slice(prefix.length + 1, prefix.length + 13)
-    const encoded = BigInt("0x" + hex)
-    return Number(encoded / BigInt(0x1000))
-  }
-}

package/src/ide/index.ts

@@ -1,76 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { spawn } from "bun"
-import z from "zod"
-import { NamedError } from "@eliseart.ai/util/error"
-import { Log } from "../util/log"
-
-const SUPPORTED_IDES = [
-  { name: "Windsurf" as const, cmd: "windsurf" },
-  { name: "Visual Studio Code - Insiders" as const, cmd: "code-insiders" },
-  { name: "Visual Studio Code" as const, cmd: "code" },
-  { name: "Cursor" as const, cmd: "cursor" },
-  { name: "VSCodium" as const, cmd: "codium" },
-]
-
-export namespace Ide {
-  const log = Log.create({ service: "ide" })
-
-  export const Event = {
-    Installed: BusEvent.define(
-      "ide.installed",
-      z.object({
-        ide: z.string(),
-      }),
-    ),
-  }
-
-  export const AlreadyInstalledError = NamedError.create("AlreadyInstalledError", z.object({}))
-
-  export const InstallFailedError = NamedError.create(
-    "InstallFailedError",
-    z.object({
-      stderr: z.string(),
-    }),
-  )
-
-  export function ide() {
-    if (process.env["TERM_PROGRAM"] === "vscode") {
-      const v = process.env["GIT_ASKPASS"]
-      for (const ide of SUPPORTED_IDES) {
-        if (v?.includes(ide.name)) return ide.name
-      }
-    }
-    return "unknown"
-  }
-
-  export function alreadyInstalled() {
-    return process.env["OPENCODE_CALLER"] === "vscode" || process.env["OPENCODE_CALLER"] === "vscode-insiders"
-  }
-
-  export async function install(ide: (typeof SUPPORTED_IDES)[number]["name"]) {
-    const cmd = SUPPORTED_IDES.find((i) => i.name === ide)?.cmd
-    if (!cmd) throw new Error(`Unknown IDE: ${ide}`)
-
-    const p = spawn([cmd, "--install-extension", "sst-dev.opencode"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-    await p.exited
-    const stdout = await new Response(p.stdout).text()
-    const stderr = await new Response(p.stderr).text()
-
-    log.info("installed", {
-      ide,
-      stdout,
-      stderr,
-    })
-
-    if (p.exitCode !== 0) {
-      throw new InstallFailedError({ stderr })
-    }
-    if (stdout.includes("already installed")) {
-      throw new AlreadyInstalledError({})
-    }
-  }
-}