@miaws/miaw 1.18.5 → 1.18.7

package/src/config/entry-name.ts

@@ -1,19 +0,0 @@
-import path from "path"
-
-// Strips a known prefix from an already-relative path. Callers should pass the
-// path relative to the directory they scanned (e.g. `path.relative(dir, item)`)
-// so the prefix match is anchored. Matching anywhere in an absolute path used
-// to mis-key agents whose home/parent segments coincidentally contained one of
-// the prefix names (see #25713).
-function stripPrefix(relativePath: string, prefixes: string[]) {
-  const normalized = relativePath.replaceAll("\\", "/")
-  for (const prefix of prefixes) {
-    if (normalized.startsWith(prefix)) return normalized.slice(prefix.length)
-  }
-}
-
-export function configEntryNameFromPath(relativePath: string, prefixes: string[]) {
-  const candidate = stripPrefix(relativePath, prefixes) ?? path.basename(relativePath)
-  const ext = path.extname(candidate)
-  return ext.length ? candidate.slice(0, -ext.length) : candidate
-}

package/src/config/managed.ts

@@ -1,69 +0,0 @@
-export * as ConfigManaged from "./managed"
-
-import { existsSync } from "fs"
-import os from "os"
-import path from "path"
-import { Process } from "@/util/process"
-
-const MANAGED_PLIST_DOMAIN = "ai.miaw.managed"
-
-// Keys injected by macOS/MDM into the managed plist that are not Miaw config
-const PLIST_META = new Set([
-  "PayloadDisplayName",
-  "PayloadIdentifier",
-  "PayloadType",
-  "PayloadUUID",
-  "PayloadVersion",
-  "_manualProfile",
-])
-
-function systemManagedConfigDir(): string {
-  switch (process.platform) {
-    case "darwin":
-      return "/Library/Application Support/miaw"
-    case "win32":
-      return path.join(process.env.ProgramData || "C:\\ProgramData", "miaw")
-    default:
-      return "/etc/miaw"
-  }
-}
-
-export function managedConfigDir() {
-  return process.env.MIAW_TEST_MANAGED_CONFIG_DIR || systemManagedConfigDir()
-}
-
-export function parseManagedPlist(json: string): string {
-  const raw = JSON.parse(json)
-  for (const key of Object.keys(raw)) {
-    if (PLIST_META.has(key)) delete raw[key]
-  }
-  return JSON.stringify(raw)
-}
-
-export async function readManagedPreferences() {
-  if (process.platform !== "darwin") return
-
-  const user = (() => {
-    try {
-      return os.userInfo().username || "user"
-    } catch {
-      return "user"
-    }
-  })()
-  const paths = [
-    path.join("/Library/Managed Preferences", user, `${MANAGED_PLIST_DOMAIN}.plist`),
-    path.join("/Library/Managed Preferences", `${MANAGED_PLIST_DOMAIN}.plist`),
-  ]
-
-  for (const plist of paths) {
-    if (!existsSync(plist)) continue
-    const result = await Process.run(["plutil", "-convert", "json", "-o", "-", plist], { nothrow: true })
-    if (result.code !== 0) continue
-    return {
-      source: `mobileconfig:${plist}`,
-      text: parseManagedPlist(result.stdout.toString()),
-    }
-  }
-
-  return
-}

package/src/config/markdown.ts

@@ -1,36 +0,0 @@
-import { Filesystem } from "@/util/filesystem"
-import { FrontmatterError } from "@miaw/core/v1/config/error"
-import { ConfigMarkdown as ConfigMarkdownCore } from "@miaw/core/config/markdown"
-
-export const FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g
-export const SHELL_REGEX = /!`([^`]+)`/g
-
-export function files(template: string) {
-  return Array.from(template.matchAll(FILE_REGEX))
-}
-
-export function shell(template: string) {
-  return Array.from(template.matchAll(SHELL_REGEX))
-}
-
-// other coding agents like claude code allow invalid yaml in their
-// frontmatter, we need to fallback to a more permissive parser for those cases
-export const fallbackSanitization = ConfigMarkdownCore.sanitize
-
-export async function parse(filePath: string) {
-  const template = await Filesystem.readText(filePath)
-
-  try {
-    return ConfigMarkdownCore.parse(template)
-  } catch (err) {
-    throw new FrontmatterError(
-      {
-        path: filePath,
-        message: `${filePath}: Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
-      },
-      { cause: err },
-    )
-  }
-}
-
-export * as ConfigMarkdown from "./markdown"

package/src/config/parse.ts

@@ -1,79 +0,0 @@
-export * as ConfigParse from "./parse"
-
-import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
-import { Cause, Exit, Schema as EffectSchema, SchemaIssue } from "effect"
-import type { DeepMutable } from "@miaw/core/schema"
-import { InvalidError, JsonError } from "@miaw/core/v1/config/error"
-
-export function jsonc(text: string, filepath: string): unknown {
-  const errors: JsoncParseError[] = []
-  const data = parseJsoncImpl(text, errors, { allowTrailingComma: true })
-  if (errors.length) {
-    const lines = text.split("\n")
-    const issues = errors
-      .map((e) => {
-        const beforeOffset = text.substring(0, e.offset).split("\n")
-        const line = beforeOffset.length
-        const column = beforeOffset[beforeOffset.length - 1].length + 1
-        const problemLine = lines[line - 1]
-
-        const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
-        if (!problemLine) return error
-
-        return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
-      })
-      .join("\n")
-    throw new JsonError({
-      path: filepath,
-      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues}\n--- End ---`,
-    })
-  }
-
-  return data
-}
-
-export function schema<S extends EffectSchema.Decoder<unknown, never>>(
-  schema: S,
-  data: unknown,
-  source: string,
-): DeepMutable<S["Type"]> {
-  const extra = topLevelExtraKeys(schema, data)
-  if (extra.length) {
-    throw new InvalidError({
-      path: source,
-      issues: [
-        {
-          code: "unrecognized_keys",
-          keys: extra,
-          path: [],
-          message: `Unrecognized key${extra.length === 1 ? "" : "s"}: ${extra.join(", ")}`,
-        },
-      ],
-    })
-  }
-
-  const decoded = EffectSchema.decodeUnknownExit(schema)(data, { errors: "all", propertyOrder: "original" })
-  if (Exit.isSuccess(decoded)) return decoded.value as DeepMutable<S["Type"]>
-  const error = Cause.squash(decoded.cause)
-
-  throw new InvalidError(
-    {
-      path: source,
-      issues: EffectSchema.isSchemaError(error)
-        ? SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => ({
-            ...issue,
-            message: issue.message,
-            path: issue.path?.map(String) ?? [],
-          }))
-        : [{ message: String(error), path: [] }],
-    },
-    { cause: error },
-  )
-}
-
-function topLevelExtraKeys(schema: EffectSchema.Top, data: unknown) {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
-  if (schema.ast._tag !== "Objects" || schema.ast.indexSignatures.length > 0) return []
-  const known = new Set(schema.ast.propertySignatures.map((item) => String(item.name)))
-  return Object.keys(data).filter((key) => !known.has(key))
-}

package/src/config/paths.ts

@@ -1,45 +0,0 @@
-export * as ConfigPaths from "./paths"
-
-import path from "path"
-import { Flag } from "@miaw/core/flag/flag"
-import { Global } from "@miaw/core/global"
-import { unique } from "remeda"
-import * as Effect from "effect/Effect"
-import { FSUtil } from "@miaw/core/fs-util"
-
-export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
-  name: string,
-  directory: string,
-  worktree?: string,
-) {
-  const afs = yield* FSUtil.Service
-  return (yield* afs.up({
-    targets: [`${name}.jsonc`, `${name}.json`],
-    start: directory,
-    stop: worktree,
-  })).toReversed()
-})
-
-export const directories = Effect.fn("ConfigPaths.directories")(function* (directory: string, worktree?: string) {
-  const afs = yield* FSUtil.Service
-  return unique([
-    Global.Path.config,
-    ...(!Flag.MIAW_DISABLE_PROJECT_CONFIG
-      ? yield* afs.up({
-          targets: [".miaw"],
-          start: directory,
-          stop: worktree,
-        })
-      : []),
-    ...(yield* afs.up({
-      targets: [".miaw"],
-      start: Global.Path.home,
-      stop: Global.Path.home,
-    })),
-    ...(Flag.MIAW_CONFIG_DIR ? [Flag.MIAW_CONFIG_DIR] : []),
-  ])
-})
-
-export function fileInDirectory(dir: string, name: string) {
-  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
-}

package/src/config/plugin.ts

@@ -1,79 +0,0 @@
-import { Glob } from "@miaw/core/util/glob"
-import { ConfigPluginV1 } from "@miaw/core/v1/config/plugin"
-import { pathToFileURL } from "url"
-import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
-import path from "path"
-
-export type Scope = "global" | "local"
-
-// Origin keeps the original config provenance attached to a spec.
-// After multiple config files are merged, callers still need to know which file declared the plugin
-// and whether it should behave like a global or project-local plugin.
-export type Origin = {
-  spec: ConfigPluginV1.Spec
-  source: string
-  scope: Scope
-}
-
-export async function load(dir: string) {
-  const plugins: ConfigPluginV1.Spec[] = []
-
-  for (const item of await Glob.scan("{plugin,plugins}/*.{ts,js}", {
-    cwd: dir,
-    absolute: true,
-    dot: true,
-    symlink: true,
-  })) {
-    plugins.push(pathToFileURL(item).href)
-  }
-  return plugins
-}
-
-export function pluginSpecifier(plugin: ConfigPluginV1.Spec): string {
-  return Array.isArray(plugin) ? plugin[0] : plugin
-}
-
-export function pluginOptions(plugin: ConfigPluginV1.Spec): ConfigPluginV1.Options | undefined {
-  return Array.isArray(plugin) ? plugin[1] : undefined
-}
-
-// Path-like specs are resolved relative to the config file that declared them so merges later on do not
-// accidentally reinterpret `./plugin.ts` relative to some other directory.
-export async function resolvePluginSpec(
-  plugin: ConfigPluginV1.Spec,
-  configFilepath: string,
-): Promise<ConfigPluginV1.Spec> {
-  const spec = pluginSpecifier(plugin)
-  if (!isPathPluginSpec(spec)) return plugin
-
-  const base = path.dirname(configFilepath)
-  const file = (() => {
-    if (spec.startsWith("file://")) return spec
-    if (path.isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec)) return pathToFileURL(spec).href
-    return pathToFileURL(path.resolve(base, spec)).href
-  })()
-
-  const resolved = await resolvePathPluginTarget(file).catch(() => file)
-
-  if (Array.isArray(plugin)) return [resolved, plugin[1]]
-  return resolved
-}
-
-// Dedupe on the load identity (package name for npm specs, exact file URL for local specs), but keep the
-// full Origin so downstream code still knows which config file won and where follow-up writes should go.
-export function deduplicatePluginOrigins(plugins: Origin[]): Origin[] {
-  const seen = new Set<string>()
-  const list: Origin[] = []
-
-  for (const plugin of plugins.toReversed()) {
-    const spec = pluginSpecifier(plugin.spec)
-    const name = spec.startsWith("file://") ? spec : parsePluginSpecifier(spec).pkg
-    if (seen.has(name)) continue
-    seen.add(name)
-    list.push(plugin)
-  }
-
-  return list.toReversed()
-}
-
-export * as ConfigPlugin from "./plugin"

package/src/config/tui-cwd.ts

@@ -1,5 +0,0 @@
-import { Context } from "effect"
-
-export const CurrentWorkingDirectory = Context.Reference<string>("CurrentWorkingDirectory", {
-  defaultValue: () => process.cwd(),
-})

package/src/config/tui-host-attention.ts

@@ -1,21 +0,0 @@
-import { TuiConfig } from "@miaw/tui/config"
-import { isRecord } from "@miaw/tui/util/record"
-import { Filesystem } from "@/util/filesystem"
-import { Schema } from "effect"
-
-export function resolveHostAttentionSoundPaths(
-  root: string,
-  sounds: unknown,
-  options?: { trim?: boolean },
-): TuiConfig.AttentionSoundPaths {
-  if (!isRecord(sounds)) return {}
-  return Object.fromEntries(
-    Object.entries(sounds).flatMap(([name, file]) => {
-      if (!Schema.is(TuiConfig.AttentionSoundName)(name)) return []
-      if (typeof file !== "string") return []
-      const value = options?.trim ? file.trim() : file
-      if (!value) return []
-      return [[name, Filesystem.resolveFilePath(root, value)]]
-    }),
-  )
-}

package/src/config/tui-migrate.ts

@@ -1,132 +0,0 @@
-import path from "path"
-import { type ParseError as JsoncParseError, applyEdits, modify, parse as parseJsonc } from "jsonc-parser"
-import { unique } from "remeda"
-import { Option, Schema } from "effect"
-import { TuiConfig } from "@miaw/tui/config"
-import { Flag } from "@miaw/core/flag/flag"
-import { Global } from "@miaw/core/global"
-import { Filesystem } from "@/util/filesystem"
-import * as ConfigPaths from "@/config/paths"
-
-const TUI_SCHEMA_URL = "https://miaw/tui.json"
-
-const decodeTheme = Schema.decodeUnknownOption(Schema.String)
-const decodeRecord = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))
-const decodeScrollSpeed = Schema.decodeUnknownOption(TuiConfig.ScrollSpeed)
-const decodeScrollAcceleration = Schema.decodeUnknownOption(TuiConfig.ScrollAcceleration)
-const decodeDiffStyle = Schema.decodeUnknownOption(TuiConfig.DiffStyle)
-
-interface MigrateInput {
-  cwd: string
-  directories: string[]
-}
-
-/**
- * Migrates tui-specific keys (theme, keybinds, tui) from miaw.json files
- * into dedicated tui.json files. Migration is performed per-directory and
- * skips only locations where a tui.json already exists.
- */
-export async function migrateTuiConfig(input: MigrateInput) {
-  const miaw = await miawFiles(input)
-  for (const file of miaw) {
-    const source = await Filesystem.readText(file).catch(() => undefined)
-    if (!source) continue
-    const errors: JsoncParseError[] = []
-    const data = parseJsonc(source, errors, { allowTrailingComma: true })
-    if (errors.length || !data || typeof data !== "object" || Array.isArray(data)) continue
-
-    const theme = decodeTheme("theme" in data ? data.theme : undefined)
-    const keybinds = decodeRecord("keybinds" in data ? data.keybinds : undefined)
-    const legacyTui = decodeRecord("tui" in data ? data.tui : undefined)
-    const extracted = {
-      theme: Option.getOrUndefined(theme),
-      keybinds: Option.getOrUndefined(keybinds),
-      tui: Option.getOrUndefined(legacyTui),
-    }
-    const tui = extracted.tui ? normalizeTui(extracted.tui) : undefined
-    if (extracted.theme === undefined && extracted.keybinds === undefined && !tui) continue
-
-    const target = path.join(path.dirname(file), "tui.json")
-    const targetExists = await Filesystem.exists(target)
-    if (targetExists) continue
-
-    const payload: Record<string, unknown> = {
-      $schema: TUI_SCHEMA_URL,
-    }
-    if (extracted.theme !== undefined) payload.theme = extracted.theme
-    if (extracted.keybinds !== undefined) payload.keybinds = extracted.keybinds
-    if (tui) Object.assign(payload, tui)
-
-    const wrote = await Filesystem.write(target, JSON.stringify(payload, null, 2))
-      .then(() => true)
-      .catch(() => false)
-    if (!wrote) continue
-
-    const stripped = await backupAndStripLegacy(file, source)
-    if (!stripped) continue
-  }
-}
-
-function normalizeTui(data: Record<string, unknown>):
-  | {
-      scroll_speed: number | undefined
-      scroll_acceleration: { enabled: boolean } | undefined
-      diff_style: "auto" | "stacked" | undefined
-    }
-  | undefined {
-  const parsed = {
-    scroll_speed: Option.getOrUndefined(decodeScrollSpeed(data.scroll_speed)),
-    scroll_acceleration: Option.getOrUndefined(decodeScrollAcceleration(data.scroll_acceleration)),
-    diff_style: Option.getOrUndefined(decodeDiffStyle(data.diff_style)),
-  }
-  return parsed.scroll_speed === undefined &&
-    parsed.diff_style === undefined &&
-    parsed.scroll_acceleration === undefined
-    ? undefined
-    : parsed
-}
-
-async function backupAndStripLegacy(file: string, source: string) {
-  const backup = file + ".tui-migration.bak"
-  const hasBackup = await Filesystem.exists(backup)
-  const backed = hasBackup
-    ? true
-    : await Filesystem.write(backup, source)
-        .then(() => true)
-        .catch(() => false)
-  if (!backed) return false
-
-  const text = ["theme", "keybinds", "tui"].reduce((acc, key) => {
-    const edits = modify(acc, [key], undefined, {
-      formattingOptions: {
-        insertSpaces: true,
-        tabSize: 2,
-      },
-    })
-    if (!edits.length) return acc
-    return applyEdits(acc, edits)
-  }, source)
-
-  return Filesystem.write(file, text)
-    .then(() => true)
-    .catch(() => false)
-}
-
-async function miawFiles(input: { directories: string[]; cwd: string }) {
-  const files = [
-    ...ConfigPaths.fileInDirectory(Global.Path.config, "miaw"),
-    ...(await Filesystem.findUp(["miaw.json", "miaw.jsonc"], input.cwd, undefined, { rootFirst: true })),
-  ]
-  for (const dir of unique(input.directories)) {
-    files.push(...ConfigPaths.fileInDirectory(dir, "miaw"))
-  }
-  if (Flag.MIAW_CONFIG) files.push(Flag.MIAW_CONFIG)
-
-  const existing = await Promise.all(
-    unique(files).map(async (file) => {
-      const ok = await Filesystem.exists(file)
-      return ok ? file : undefined
-    }),
-  )
-  return existing.filter((file): file is string => !!file)
-}