@miaws/miaw 1.18.4 → 1.18.5

package/src/effect/runtime-flags.ts

@@ -0,0 +1,79 @@
+import { Config, ConfigProvider, Context, Effect, Layer, Option } from "effect"
+import { ConfigService } from "@/effect/config-service"
+
+const bool = (name: string) => Config.boolean(name).pipe(Config.withDefault(false))
+const positiveInteger = (name: string) =>
+  Config.number(name).pipe(
+    Config.map((value) => (Number.isInteger(value) && value > 0 ? value : undefined)),
+    Config.orElse(() => Config.succeed(undefined)),
+  )
+const experimental = bool("MIAW_EXPERIMENTAL")
+const enabledByExperimental = (name: string) =>
+  Config.all({ experimental, enabled: Config.boolean(name).pipe(Config.option) }).pipe(
+    Config.map((flags) => Option.getOrElse(flags.enabled, () => flags.experimental)),
+  )
+
+export class Service extends ConfigService.Service<Service>()("@miaw/RuntimeFlags", {
+  autoShare: bool("MIAW_AUTO_SHARE"),
+  pure: bool("MIAW_PURE"),
+  disableDefaultPlugins: bool("MIAW_DISABLE_DEFAULT_PLUGINS"),
+  disableEmbeddedWebUi: bool("MIAW_DISABLE_EMBEDDED_WEB_UI"),
+  disableExternalSkills: bool("MIAW_DISABLE_EXTERNAL_SKILLS"),
+  disableLspDownload: bool("MIAW_DISABLE_LSP_DOWNLOAD"),
+  disableClaudeCodePrompt: Config.all({
+    broad: bool("MIAW_DISABLE_CLAUDE_CODE"),
+    direct: bool("MIAW_DISABLE_CLAUDE_CODE_PROMPT"),
+  }).pipe(Config.map((flags) => flags.broad || flags.direct)),
+  disableClaudeCodeSkills: Config.all({
+    broad: bool("MIAW_DISABLE_CLAUDE_CODE"),
+    direct: bool("MIAW_DISABLE_CLAUDE_CODE_SKILLS"),
+  }).pipe(Config.map((flags) => flags.broad || flags.direct)),
+  enableExa: Config.all({
+    experimental,
+    enabled: bool("MIAW_ENABLE_EXA"),
+    legacy: bool("MIAW_EXPERIMENTAL_EXA"),
+  }).pipe(Config.map((flags) => flags.experimental || flags.enabled || flags.legacy)),
+  enableParallel: Config.all({
+    enabled: bool("MIAW_ENABLE_PARALLEL"),
+    legacy: bool("MIAW_EXPERIMENTAL_PARALLEL"),
+  }).pipe(Config.map((flags) => flags.enabled || flags.legacy)),
+  enableExperimentalModels: bool("MIAW_ENABLE_EXPERIMENTAL_MODELS"),
+  enableQuestionTool: bool("MIAW_ENABLE_QUESTION_TOOL"),
+  experimentalReferences: enabledByExperimental("MIAW_EXPERIMENTAL_REFERENCES"),
+  experimentalBackgroundSubagents: enabledByExperimental("MIAW_EXPERIMENTAL_BACKGROUND_SUBAGENTS"),
+  experimentalLspTy: bool("MIAW_EXPERIMENTAL_LSP_TY"),
+  experimentalLspTool: enabledByExperimental("MIAW_EXPERIMENTAL_LSP_TOOL"),
+  experimentalOxfmt: enabledByExperimental("MIAW_EXPERIMENTAL_OXFMT"),
+  experimentalPlanMode: enabledByExperimental("MIAW_EXPERIMENTAL_PLAN_MODE"),
+  experimentalEventSystem: enabledByExperimental("MIAW_EXPERIMENTAL_EVENT_SYSTEM"),
+  experimentalWorkspaces: enabledByExperimental("MIAW_EXPERIMENTAL_WORKSPACES"),
+  experimentalIconDiscovery: enabledByExperimental("MIAW_EXPERIMENTAL_ICON_DISCOVERY"),
+  outputTokenMax: positiveInteger("MIAW_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
+  bashDefaultTimeoutMs: positiveInteger("MIAW_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
+  experimentalNativeLlm: bool("MIAW_EXPERIMENTAL_NATIVE_LLM"),
+  experimentalWebSockets: bool("MIAW_EXPERIMENTAL_WEBSOCKETS"),
+  client: Config.string("MIAW_CLIENT").pipe(Config.withDefault("cli")),
+}) {}
+
+export type Info = Context.Service.Shape<typeof Service>
+
+const emptyConfigLayer = Service.defaultLayer.pipe(
+  Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))),
+  Layer.orDie,
+)
+
+export const layer = (overrides: Partial<Info> = {}) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const flags = yield* Service
+      return Service.of({ ...flags, ...overrides })
+    }),
+  ).pipe(Layer.provide(emptyConfigLayer))
+
+export const defaultLayer = Service.defaultLayer.pipe(Layer.orDie)
+
+export const node = LayerNode.make(defaultLayer, [])
+
+export * as RuntimeFlags from "./runtime-flags"
+import { LayerNode } from "@miaw/core/effect/layer-node"

package/src/env/index.ts

@@ -0,0 +1,43 @@
+import { LayerNode } from "@miaw/core/effect/layer-node"
+import { Context, Effect, Layer } from "effect"
+import { serviceUse } from "@miaw/core/effect/service-use"
+import { InstanceState } from "@/effect/instance-state"
+
+type State = Record<string, string | undefined>
+
+export interface Interface {
+  readonly get: (key: string) => Effect.Effect<string | undefined>
+  readonly all: () => Effect.Effect<State>
+  readonly set: (key: string, value: string) => Effect.Effect<void>
+  readonly remove: (key: string) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@miaw/Env") {}
+
+export const use = serviceUse(Service)
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const state = yield* InstanceState.make<State>(Effect.fn("Env.state")(() => Effect.succeed({ ...process.env })))
+
+    const get = Effect.fn("Env.get")((key: string) => InstanceState.use(state, (env) => env[key]))
+    const all = Effect.fn("Env.all")(() => InstanceState.get(state))
+    const set = Effect.fn("Env.set")(function* (key: string, value: string) {
+      const env = yield* InstanceState.get(state)
+      env[key] = value
+    })
+    const remove = Effect.fn("Env.remove")(function* (key: string) {
+      const env = yield* InstanceState.get(state)
+      delete env[key]
+    })
+
+    return Service.of({ get, all, set, remove })
+  }),
+)
+
+export const defaultLayer = layer
+
+export const node = LayerNode.make(layer, [])
+
+export * as Env from "."

package/src/event-v2-bridge.ts

@@ -0,0 +1,79 @@
+// Miaw publish boundary for core events. Attach routed instance location
+// so direct EventV2 consumers can isolate directory/workspace streams.
+import { LayerNode } from "@miaw/core/effect/layer-node"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { GlobalBus } from "@/bus/global"
+import { EventV2 } from "@miaw/core/event"
+import { Location } from "@miaw/core/location"
+import { Project } from "@miaw/core/project"
+import { AbsolutePath } from "@miaw/core/schema"
+import "@miaw/core/account"
+import "@miaw/core/catalog"
+import "@miaw/core/session/event"
+import { Context, Effect, Layer } from "effect"
+
+export class Service extends Context.Service<Service, EventV2.Interface>()("@miaw/EventV2Bridge") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const events = yield* EventV2.Service
+
+    const publish: EventV2.Interface["publish"] = (definition, data, options) =>
+      Effect.gen(function* () {
+        if (options?.location) return yield* events.publish(definition, data, options)
+        const ctx = yield* InstanceRef
+        if (!ctx) return yield* events.publish(definition, data, options)
+        const workspaceID = yield* WorkspaceRef
+        return yield* events.publish(definition, data, {
+          ...options,
+          location: new Location.Info({
+            directory: AbsolutePath.make(ctx.directory),
+            ...(workspaceID ? { workspaceID } : {}),
+            project: { id: Project.ID.make(ctx.project.id), directory: AbsolutePath.make(ctx.worktree) },
+          }),
+        })
+      })
+
+    const unsubscribe = yield* events.listen((event) =>
+      Effect.gen(function* () {
+        const ctx = yield* InstanceRef
+        const workspaceID = (yield* WorkspaceRef) ?? event.location?.workspaceID
+        GlobalBus.emit("event", {
+          directory: event.location?.directory ?? ctx?.directory,
+          project: ctx?.project.id,
+          workspace: workspaceID,
+          payload: { id: event.id, type: event.type, properties: event.data },
+        })
+        const sync = EventV2.registry.get(event.type)?.sync
+        if (sync === undefined || event.seq === undefined || event.version === undefined) return
+        const aggregateID = (event.data as Record<string, unknown>)[sync.aggregate]
+        if (typeof aggregateID !== "string") return
+        GlobalBus.emit("event", {
+          directory: event.location?.directory ?? ctx?.directory,
+          project: ctx?.project.id,
+          workspace: workspaceID,
+          payload: {
+            type: "sync",
+            syncEvent: {
+              id: event.id,
+              type: EventV2.versionedType(event.type, event.version),
+              seq: event.seq,
+              aggregateID,
+              data: event.data,
+            },
+          },
+        })
+      }),
+    )
+    yield* Effect.addFinalizer(() => unsubscribe)
+
+    return Service.of({ ...events, publish })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(EventV2.defaultLayer))
+
+export const node = LayerNode.make(layer, [EventV2.node])
+
+export * as EventV2Bridge from "./event-v2-bridge"

package/src/format/formatter.ts

@@ -0,0 +1,404 @@
+import { Npm } from "@miaw/core/npm"
+import type { InstanceContext } from "../project/instance-context"
+import { Filesystem } from "@/util/filesystem"
+import { Process } from "@/util/process"
+import { which } from "@miaw/core/util/which"
+
+export interface Context extends Pick<InstanceContext, "directory" | "worktree"> {
+  experimentalOxfmt: boolean
+}
+
+export interface Info {
+  name: string
+  environment?: Record<string, string>
+  extensions: string[]
+  enabled(context: Context): Promise<string[] | false>
+}
+
+export const gofmt: Info = {
+  name: "gofmt",
+  extensions: [".go"],
+  async enabled() {
+    const match = which("gofmt")
+    if (!match) return false
+    return [match, "-w", "$FILE"]
+  },
+}
+
+export const mix: Info = {
+  name: "mix",
+  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+  async enabled() {
+    const match = which("mix")
+    if (!match) return false
+    return [match, "format", "$FILE"]
+  },
+}
+
+export const prettier: Info = {
+  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",
+  ],
+  async enabled(context) {
+    const items = await Filesystem.findUp("package.json", context.directory, context.worktree)
+    for (const item of items) {
+      const json = await Filesystem.readJson<{
+        dependencies?: Record<string, string>
+        devDependencies?: Record<string, string>
+      }>(item)
+      if (json.dependencies?.prettier || json.devDependencies?.prettier) {
+        const bin = await Npm.which("prettier")
+        if (bin) return [bin, "--write", "$FILE"]
+      }
+    }
+    return false
+  },
+}
+
+export const oxfmt: Info = {
+  name: "oxfmt",
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"],
+  async enabled(context) {
+    if (!context.experimentalOxfmt) return false
+    const items = await Filesystem.findUp("package.json", context.directory, context.worktree)
+    for (const item of items) {
+      const json = await Filesystem.readJson<{
+        dependencies?: Record<string, string>
+        devDependencies?: Record<string, string>
+      }>(item)
+      if (json.dependencies?.oxfmt || json.devDependencies?.oxfmt) {
+        const bin = await Npm.which("oxfmt")
+        if (bin) return [bin, "$FILE"]
+      }
+    }
+    return false
+  },
+}
+
+export const biome: Info = {
+  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",
+  ],
+  async enabled(context) {
+    const configs = ["biome.json", "biome.jsonc"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, context.directory, context.worktree)
+      if (found.length > 0) {
+        const bin = await Npm.which("@biomejs/biome")
+        if (bin) return [bin, "format", "--write", "$FILE"]
+      }
+    }
+    return false
+  },
+}
+
+export const zig: Info = {
+  name: "zig",
+  extensions: [".zig", ".zon"],
+  async enabled() {
+    const match = which("zig")
+    if (!match) return false
+    return [match, "fmt", "$FILE"]
+  },
+}
+
+export const clang: Info = {
+  name: "clang-format",
+  extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+  async enabled(context) {
+    const items = await Filesystem.findUp(".clang-format", context.directory, context.worktree)
+    if (items.length > 0) {
+      const match = which("clang-format")
+      if (match) return [match, "-i", "$FILE"]
+    }
+    return false
+  },
+}
+
+export const ktlint: Info = {
+  name: "ktlint",
+  extensions: [".kt", ".kts"],
+  async enabled() {
+    const match = which("ktlint")
+    if (!match) return false
+    return [match, "-F", "$FILE"]
+  },
+}
+
+export const ruff: Info = {
+  name: "ruff",
+  extensions: [".py", ".pyi"],
+  async enabled(context) {
+    if (!which("ruff")) return false
+    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, context.directory, context.worktree)
+      if (found.length > 0) {
+        if (config === "pyproject.toml") {
+          const content = await Filesystem.readText(found[0])
+          if (content.includes("[tool.ruff]")) return ["ruff", "format", "$FILE"]
+        } else {
+          return ["ruff", "format", "$FILE"]
+        }
+      }
+    }
+    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    for (const dep of deps) {
+      const found = await Filesystem.findUp(dep, context.directory, context.worktree)
+      if (found.length > 0) {
+        const content = await Filesystem.readText(found[0])
+        if (content.includes("ruff")) return ["ruff", "format", "$FILE"]
+      }
+    }
+    return false
+  },
+}
+
+export const rlang: Info = {
+  name: "air",
+  extensions: [".R"],
+  async enabled() {
+    const air = which("air")
+    if (air == null) return false
+
+    const output = await Process.text([air, "--help"], { nothrow: true })
+
+    // Check for "Air: An R language server and formatter"
+    const firstLine = output.text.split("\n")[0]
+    const hasR = firstLine.includes("R language")
+    const hasFormatter = firstLine.includes("formatter")
+    if (output.code === 0 && hasR && hasFormatter) return [air, "format", "$FILE"]
+    return false
+  },
+}
+
+export const uvformat: Info = {
+  name: "uv",
+  extensions: [".py", ".pyi"],
+  async enabled(context) {
+    if (await ruff.enabled(context)) return false
+    const uv = which("uv")
+    if (uv == null) return false
+    const output = await Process.run([uv, "format", "--help"], { nothrow: true })
+    if (output.code === 0) return [uv, "format", "--", "$FILE"]
+    return false
+  },
+}
+
+export const rubocop: Info = {
+  name: "rubocop",
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    const match = which("rubocop")
+    if (!match) return false
+    return [match, "--autocorrect", "$FILE"]
+  },
+}
+
+export const standardrb: Info = {
+  name: "standardrb",
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    const match = which("standardrb")
+    if (!match) return false
+    return [match, "--fix", "$FILE"]
+  },
+}
+
+export const htmlbeautifier: Info = {
+  name: "htmlbeautifier",
+  extensions: [".erb", ".html.erb"],
+  async enabled() {
+    const match = which("htmlbeautifier")
+    if (!match) return false
+    return [match, "$FILE"]
+  },
+}
+
+export const dart: Info = {
+  name: "dart",
+  extensions: [".dart"],
+  async enabled() {
+    const match = which("dart")
+    if (!match) return false
+    return [match, "format", "$FILE"]
+  },
+}
+
+export const ocamlformat: Info = {
+  name: "ocamlformat",
+  extensions: [".ml", ".mli"],
+  async enabled(context) {
+    if (!which("ocamlformat")) return false
+    const items = await Filesystem.findUp(".ocamlformat", context.directory, context.worktree)
+    if (items.length > 0) return ["ocamlformat", "-i", "$FILE"]
+    return false
+  },
+}
+
+export const terraform: Info = {
+  name: "terraform",
+  extensions: [".tf", ".tfvars"],
+  async enabled() {
+    const match = which("terraform")
+    if (!match) return false
+    return [match, "fmt", "$FILE"]
+  },
+}
+
+export const latexindent: Info = {
+  name: "latexindent",
+  extensions: [".tex"],
+  async enabled() {
+    const match = which("latexindent")
+    if (!match) return false
+    return [match, "-w", "-s", "$FILE"]
+  },
+}
+
+export const gleam: Info = {
+  name: "gleam",
+  extensions: [".gleam"],
+  async enabled() {
+    const match = which("gleam")
+    if (!match) return false
+    return [match, "format", "$FILE"]
+  },
+}
+
+export const shfmt: Info = {
+  name: "shfmt",
+  extensions: [".sh", ".bash"],
+  async enabled() {
+    const match = which("shfmt")
+    if (!match) return false
+    return [match, "-w", "$FILE"]
+  },
+}
+
+export const nixfmt: Info = {
+  name: "nixfmt",
+  extensions: [".nix"],
+  async enabled() {
+    const match = which("nixfmt")
+    if (!match) return false
+    return [match, "$FILE"]
+  },
+}
+
+export const rustfmt: Info = {
+  name: "rustfmt",
+  extensions: [".rs"],
+  async enabled() {
+    const match = which("rustfmt")
+    if (!match) return false
+    return [match, "$FILE"]
+  },
+}
+
+export const pint: Info = {
+  name: "pint",
+  extensions: [".php"],
+  async enabled(context) {
+    const items = await Filesystem.findUp("composer.json", context.directory, context.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"] || json["require-dev"]?.["laravel/pint"]) return ["./vendor/bin/pint", "$FILE"]
+    }
+    return false
+  },
+}
+
+export const ormolu: Info = {
+  name: "ormolu",
+  extensions: [".hs"],
+  async enabled() {
+    const match = which("ormolu")
+    if (!match) return false
+    return [match, "-i", "$FILE"]
+  },
+}
+
+export const cljfmt: Info = {
+  name: "cljfmt",
+  extensions: [".clj", ".cljs", ".cljc", ".edn"],
+  async enabled() {
+    const match = which("cljfmt")
+    if (!match) return false
+    return [match, "fix", "--quiet", "$FILE"]
+  },
+}
+
+export const dfmt: Info = {
+  name: "dfmt",
+  extensions: [".d"],
+  async enabled() {
+    const match = which("dfmt")
+    if (!match) return false
+    return [match, "-i", "$FILE"]
+  },
+}