agent-simple-english 0.5.1 → 0.7.0

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
     {
       "name": "simple-english",
       "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
-      "version": "0.5.1",
+      "version": "0.7.0",
       "author": {
         "name": "JIA YI"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "simple-english",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Apply technical and house-style writing rules to writes, edits, and git commit messages.",
   "repository": "https://github.com/jyooi/agent-simple-english",
   "license": "MIT",

package/README.md

@@ -73,6 +73,11 @@ The `/ase` command controls the current Claude Code session.
 New sessions start in enabled mode without a strict reply gate.
 A change in one session does not change a parallel session.
 
+The full command name is `/simple-english:ase`, and it always runs.
+The short name `/ase` runs the same command.
+If a user command or a project command has the name `ase`, that command takes the short name.
+Then use the full name.
+
 | Command | Result |
 | --- | --- |
 | `/ase on` | Enable write, edit, commit, and reply checks. |
@@ -80,6 +85,16 @@ A change in one session does not change a parallel session.
 | `/ase status` | Show the mode, rule counts, and dictionary state. |
 | `/ase strict` | Enable the strict reply gate and all other checks. |
 | `/ase strict off` | Disable the strict reply gate and use reply feedback. |
+| `/ase explain` | Write the last reply again in Simplified Technical English. |
+
+Claude Code 2.1.292 or later shows argument suggestions while you type.
+Type `/ase`, press Tab to select the command, then type the first letters of an argument.
+The list shows each argument that starts with those letters, and Tab completes the first one.
+After `strict`, the list suggests `off`.
+
+An earlier Claude Code version shows only the fixed argument hint.
+Claude Code 2.1.287 to 2.1.291 also show one load error for the suggestion module at session start.
+The writing-rule hooks continue to operate on those versions.
 
 Strict mode blocks a `Stop` event when the reply has a hard violation.
 Claude Code then uses the violation details to write the reply again.
@@ -131,7 +146,7 @@ pi -e .
 
 The mode applies to the current pi session.
 The extension starts in enabled mode without strict reply gating.
-Type `/ase ` to see autocomplete suggestions for `on`, `off`, `status`, and `strict`.
+Type `/ase ` to see autocomplete suggestions for `on`, `off`, `status`, `strict`, and `strict off`.
 The list changes to match the text that you type.
 
 | Command | Result |
@@ -360,7 +375,7 @@ The project file is `.simple-english.json` at the repository root.
 The global file is `$XDG_CONFIG_HOME/simple-english/config.json`.
 If `XDG_CONFIG_HOME` is unset or not absolute, the global path is `~/.config/simple-english/config.json`.
 
-Global and project files are deep-merged.
+Global and project files merge key by key, including the nested `rules` and `ruleDataExtensions` objects.
 Global values load first, and project values have precedence.
 The pi Adapter reads the project file only when pi trusts the project.
 The `--config` flag uses only its named file.

package/commands/ase.md

@@ -1,13 +1,14 @@
 ---
+name: ase
 description: Control writing-rule enforcement for this Claude Code session
-argument-hint: on|off|status|strict|strict off
+argument-hint: on|off|status|strict|strict off|explain
 allowed-tools: Bash
 disable-model-invocation: true
 ---
 
-Session state:
+Command output:
 
 !`cd "${CLAUDE_PLUGIN_ROOT}" && bun "src/cli/main.ts" session "${CLAUDE_SESSION_ID}" "${CLAUDE_PROJECT_DIR}" "$ARGUMENTS"`
 
-Show the session state exactly.
-Do not add text.
+If the output starts with "## Rewrite request", do what it asks.
+Otherwise, show the output exactly and add no text.

package/hooks/hooks.json

@@ -1,6 +1,8 @@
 {
   "description": "Inject active writing rules, gate changes, and return reply feedback on the next prompt.",
 
+  "modules": ["./register.ts"],
+
   "hooks": {
     "SessionStart": [
       {

package/hooks/register.ts

@@ -0,0 +1,51 @@
+interface Suggestion {
+  readonly text: string
+  readonly description: string
+}
+
+interface AutocompleteInput {
+  readonly text: string
+  readonly token: string
+  readonly start: number
+}
+
+interface AutocompleteResult {
+  readonly suggestions: readonly Suggestion[]
+}
+
+type AutocompleteHook = (
+  engine: unknown,
+  input: AutocompleteInput,
+  next: (input: AutocompleteInput) => Promise<AutocompleteResult>,
+) => Promise<AutocompleteResult>
+
+const FIRST_WORDS: readonly Suggestion[] = [
+  { text: "on", description: "Enable write, edit, commit, and reply checks" },
+  { text: "off", description: "Disable all checks and leave strict mode" },
+  { text: "status", description: "Show the mode, rule counts, and dictionary state" },
+  { text: "strict", description: "Enable the strict reply gate and all other checks" },
+  { text: "explain", description: "Write the last reply again in Simplified Technical English" },
+]
+
+const WORDS_AFTER_STRICT: readonly Suggestion[] = [
+  { text: "off", description: "Disable the strict reply gate and use reply feedback" },
+]
+
+export function aseSuggestions(text: string, token: string, start: number): readonly Suggestion[] {
+  const head = /^\/(?:simple-english:)?ase\s+(.*)$/u.exec(text.slice(0, start))
+  if (head === null) return []
+  const earlierWords = (head[1] ?? "").trim().toLowerCase()
+  const words =
+    earlierWords === "" ? FIRST_WORDS : earlierWords === "strict" ? WORDS_AFTER_STRICT : []
+  const typed = token.toLowerCase()
+  return words.filter((word) => word.text.startsWith(typed) && word.text !== typed)
+}
+
+export function register(on: (event: "prompt.autocomplete", hook: AutocompleteHook) => void): void {
+  on("prompt.autocomplete", async (_engine, input, next) => ({
+    suggestions: [
+      ...aseSuggestions(input.text, input.token, input.start),
+      ...(await next(input)).suggestions,
+    ],
+  }))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-simple-english",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@lezer/html": "^1.3.12",
     "@lezer/markdown": "^1.7.2",
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.1",
     "micromark": "^4.0.2",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm-table": "^2.1.1",

package/src/adapter/rule-summary.ts

@@ -1,23 +1,8 @@
 import type { SteConfig } from "../config/schema.ts"
 import { DEFAULT_MAX_SENTENCE_WORDS } from "../engine/lint.ts"
-import type { RuleId } from "../engine/rules/registry.ts"
+import { DEFAULT_SEVERITIES, type RuleId } from "../engine/rules/registry.ts"
 import type { RuleSetting } from "../engine/types.ts"
 
-const DEFAULT_RULE_SETTINGS: Readonly<Record<RuleId, RuleSetting>> = {
-  contraction: "hard",
-  "dictionary-not-approved-word": "hard",
-  hedging: "soft",
-  "invalid-suppression": "hard",
-  marketing: "soft",
-  "paragraph-length": "hard",
-  "phrasal-verb": "hard",
-  semicolon: "hard",
-  "sentence-length": "hard",
-  "verb-progressive": "hard",
-  "verb-passive": "soft",
-  "verb-perfect": "hard",
-}
-
 export const RULE_SUMMARIES: Readonly<Record<RuleId, string>> = {
   contraction: "Do not use contractions. Write the words in full.",
   "dictionary-not-approved-word": "Use approved words from the STE dictionary.",
@@ -34,7 +19,7 @@ export const RULE_SUMMARIES: Readonly<Record<RuleId, string>> = {
 }
 
 export function resolvedRuleSetting(config: SteConfig, ruleId: RuleId): RuleSetting {
-  return config.rules?.[ruleId] ?? DEFAULT_RULE_SETTINGS[ruleId]
+  return config.rules?.[ruleId] ?? DEFAULT_SEVERITIES[ruleId]
 }
 
 export function formatFailedStatusSummary(
@@ -87,7 +72,7 @@ function formatRuleGroup(
   return `### ${heading}\n\n${rules.join("\n")}`
 }
 
-export function ruleSummary(config: SteConfig): string {
+function enabledRuleSections(config: SteConfig): string | undefined {
   const maxSentenceWords = config.maxSentenceWords ?? DEFAULT_MAX_SENTENCE_WORDS
   const ruleIds = Object.keys(RULE_SUMMARIES) as RuleId[]
   const sections = [
@@ -112,9 +97,22 @@ export function ruleSummary(config: SteConfig): string {
       maxSentenceWords,
     ),
   ].filter((section): section is string => section !== undefined)
+  return sections.length === 0 ? undefined : sections.join("\n\n")
+}
+
+const NO_RULES_ENABLED = "No writing rules are enabled."
+
+export function ruleSummary(config: SteConfig): string {
+  const sections = enabledRuleSections(config)
   const rules =
-    sections.length === 0
-      ? "No writing rules are enabled."
-      : `Apply these enabled rules to prose that you write or edit:\n\n${sections.join("\n\n")}`
-  return `## Writing rules\n\n${rules}\n\nWrites, edits, and git commit messages reject hard violations. Correct the reported text and retry. Soft violations produce warnings.`
+    sections === undefined
+      ? NO_RULES_ENABLED
+      : `Write all prose in ASD-STE100 Simplified Technical English, including your replies to the user. Apply these enabled rules:\n\n${sections}`
+  return `## Writing rules\n\n${rules}\n\nWrites, edits, and git commit messages reject hard violations. Correct the reported text and retry. Soft violations produce warnings. Replies are also checked.`
+}
+
+export function explainRequest(config: SteConfig): string {
+  const sections = enabledRuleSections(config)
+  if (sections === undefined) return NO_RULES_ENABLED
+  return `## Rewrite request\n\nWrite your last reply again in ASD-STE100 Simplified Technical English. Keep all facts, code, commands, paths, and numbers the same. Do not add new content.\n\nApply these enabled rules:\n\n${sections}`
 }

package/src/cli/hook.ts

@@ -12,7 +12,6 @@ import { classifyPath } from "../engine/kinds.ts"
 import { lint } from "../engine/lint.ts"
 import type { Tagger } from "../engine/tagger.ts"
 import type { LintKind, LintOptions, ReportViolation } from "../engine/types.ts"
-import { TaggerService } from "../tagger/wink.ts"
 import {
   appendObservation,
   type ObservationDraft,
@@ -638,7 +637,7 @@ function recordEvaluation(event: HookEvent, evaluation: HookEvaluation): Effect.
   )
 }
 
-export function runHookMode(raw: string): Effect.Effect<HookOutput, never, TaggerService> {
+export function runHookMode(raw: string, tagger: Tagger): Effect.Effect<HookOutput, never> {
   return Effect.try({
     try: () => decodeEvent(raw),
     catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
@@ -647,7 +646,7 @@ export function runHookMode(raw: string): Effect.Effect<HookOutput, never, Tagge
       onFailure: (error) => Effect.succeed(nonBlockingError(error.message)),
       onSuccess: (event) =>
         readSessionControl(event.sessionId).pipe(
-          Effect.flatMap((control): Effect.Effect<HookOutput, Error, TaggerService> => {
+          Effect.flatMap((control): Effect.Effect<HookOutput, Error> => {
             if (!control.enabled) {
               return Effect.succeed(
                 event.hookEventName === "PreToolUse" ? allow() : ({} as Record<string, never>),
@@ -665,18 +664,11 @@ export function runHookMode(raw: string): Effect.Effect<HookOutput, never, Tagge
                 ),
               )
             }
-            if (event.hookEventName === "Stop") {
-              return Effect.gen(function* () {
-                const tagger = yield* TaggerService
-                const evaluation = yield* evaluateReply(event, tagger)
-                return yield* recordEvaluation(event, evaluation)
-              })
-            }
-            return Effect.gen(function* () {
-              const tagger = yield* TaggerService
-              const evaluation = yield* evaluateEvent(event, tagger)
-              return yield* recordEvaluation(event, evaluation)
-            })
+            const evaluation =
+              event.hookEventName === "Stop"
+                ? evaluateReply(event, tagger)
+                : evaluateEvent(event, tagger)
+            return evaluation.pipe(Effect.flatMap((result) => recordEvaluation(event, result)))
           }),
           Effect.catch((error) =>
             Effect.succeed(

package/src/cli/main.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { readFile } from "node:fs/promises"
+import { parseArgs } from "node:util"
 import { Effect, Result } from "effect"
 import packageManifest from "../../package.json" with { type: "json" }
 import { splitViolations } from "../adapter/feedback.ts"
@@ -9,10 +10,11 @@ import { loadRuleData } from "../dictionary/load.ts"
 import { classifyPath, type PathClassification } from "../engine/kinds.ts"
 import { lint } from "../engine/lint.ts"
 import type { LintKind, LintReport } from "../engine/types.ts"
-import { TaggerService, WinkTaggerLive } from "../tagger/wink.ts"
+import { makeLazyWinkTagger } from "../tagger/wink.ts"
 import { hookInternalFailure, runHookMode } from "./hook.ts"
 import { observationStats, reviewObservations } from "./observation-log.ts"
 import { runSessionCommand } from "./session-command.ts"
+import { tryAsync } from "./try-async.ts"
 
 const KINDS: readonly LintKind[] = [
   "prose-file",
@@ -33,58 +35,41 @@ Options:
   --help           Print this help.
   --version        Print the package version.`
 
-interface CliArgs {
-  readonly json: boolean
-  readonly configPath: string | undefined
-  readonly kind: string | undefined
-  readonly kindMissingValue: boolean
-  readonly help: boolean
-  readonly version: boolean
-  readonly paths: readonly string[]
+const CLI_OPTIONS = {
+  json: { type: "boolean" },
+  config: { type: "string" },
+  kind: { type: "string" },
+  help: { type: "boolean" },
+  version: { type: "boolean" },
+} as const
+
+type CliArgs = ReturnType<typeof parseCliArgs>["values"]
+
+const parseCliArgs = (args: readonly string[]) =>
+  parseArgs({ args: [...args], options: CLI_OPTIONS, allowPositionals: true, strict: true })
+
+const argumentError = (cause: unknown): Error => {
+  const error = cause as { code?: string; message: string }
+  const flag = /'(-{1,2}[\w-]+)/u.exec(error.message)?.[1]
+  if (error.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") return new Error(`unknown flag "${flag}"`)
+  if (error.code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE" && flag === "--config") {
+    return new Error("--config requires a file path")
+  }
+  if (error.code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE" && flag === "--kind") {
+    return new Error(`--kind requires a value; expected one of: ${KINDS.join(", ")}`)
+  }
+  return new Error(error.message)
 }
 
-const parseArgs = (args: readonly string[]): Effect.Effect<CliArgs, Error> =>
-  Effect.gen(function* () {
-    let json = false
-    let configPath: string | undefined
-    let kind: string | undefined
-    let kindMissingValue = false
-    let help = false
-    let version = false
-    const paths: string[] = []
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i] as string
-      if (arg === "--json") {
-        json = true
-      } else if (arg === "--config") {
-        const value = args[i + 1]
-        if (value === undefined || value.startsWith("--")) {
-          yield* Effect.fail(new Error("--config requires a file path"))
-        }
-        configPath = value
-        i++
-      } else if (arg === "--kind") {
-        const value = args[i + 1]
-        if (value === undefined || value.startsWith("--")) {
-          kindMissingValue = true
-        } else {
-          kind = value
-          i++
-        }
-      } else if (arg.startsWith("--kind=")) {
-        kind = arg.slice("--kind=".length)
-      } else if (arg === "--help") {
-        help = true
-      } else if (arg === "--version") {
-        version = true
-      } else if (arg.startsWith("--")) {
-        yield* Effect.fail(new Error(`unknown flag "${arg}"`))
-      } else {
-        paths.push(arg)
-      }
-    }
-    return { json, configPath, kind, kindMissingValue, help, version, paths }
-  })
+// parseArgs accepts "--kind --json" with "--json" as the value. Reject that.
+const rejectOptionValue = (values: CliArgs): Effect.Effect<void, Error> => {
+  if (values.config?.startsWith("--"))
+    return Effect.fail(new Error("--config requires a file path"))
+  if (values.kind?.startsWith("--")) {
+    return Effect.fail(new Error(`--kind requires a value; expected one of: ${KINDS.join(", ")}`))
+  }
+  return Effect.void
+}
 
 const rejectUnknownFlags = (args: readonly string[]): Effect.Effect<void, Error> => {
   const flag = args.find((arg) => arg.startsWith("--"))
@@ -122,10 +107,9 @@ const readStdin = Effect.promise(async () => {
 const readInput = (path: string) =>
   path === "-"
     ? readStdin.pipe(Effect.map((text) => ({ path: "<stdin>", text })))
-    : Effect.tryPromise({
-        try: () => readFile(path, "utf8"),
-        catch: (cause) => new Error(`cannot read ${path}: ${cause}`),
-      }).pipe(Effect.map((text) => ({ path, text })))
+    : tryAsync(`cannot read ${path}`, () => readFile(path, "utf8")).pipe(
+        Effect.map((text) => ({ path, text })),
+      )
 
 const toCliReport = (
   reports: readonly { path: string; report: LintReport }[],
@@ -158,9 +142,10 @@ const render = (report: CliReport, json: boolean): string => {
 }
 
 const args = process.argv.slice(2)
+const tagger = makeLazyWinkTagger()
 
 const hookProgram = Effect.gen(function* () {
-  const output = yield* runHookMode(yield* readStdin).pipe(Effect.provide(WinkTaggerLive))
+  const output = yield* runHookMode(yield* readStdin, tagger)
   console.log(JSON.stringify(output))
   return 0
 }).pipe(
@@ -183,24 +168,20 @@ const observeProgram = Effect.gen(function* () {
     return yield* Effect.fail(new Error("Usage: simple-english observe <review|stats>"))
   }
   if (command === "review") {
-    yield* Effect.tryPromise({
-      try: () => reviewObservations(),
-      catch: (cause) => new Error(`cannot review observations: ${cause}`),
-    })
+    yield* tryAsync("cannot review observations", reviewObservations)
   } else {
-    console.log(
-      yield* Effect.tryPromise({
-        try: () => observationStats(),
-        catch: (cause) => new Error(`cannot read observation stats: ${cause}`),
-      }),
-    )
+    console.log(yield* tryAsync("cannot read observation stats", observationStats))
   }
   return 0
 })
 
 const lintProgram = Effect.gen(function* () {
-  const tagger = yield* TaggerService
-  const { json, configPath, kind, kindMissingValue, help, version, paths } = yield* parseArgs(args)
+  const { values, positionals: paths } = yield* Effect.try({
+    try: () => parseCliArgs(args),
+    catch: argumentError,
+  })
+  yield* rejectOptionValue(values)
+  const { json = false, config: configPath, kind, help, version } = values
   if (help) {
     console.log(USAGE)
     return 0
@@ -209,11 +190,6 @@ const lintProgram = Effect.gen(function* () {
     console.log(packageManifest.version)
     return 0
   }
-  if (kindMissingValue) {
-    return yield* Effect.fail(
-      new Error(`--kind requires a value; expected one of: ${KINDS.join(", ")}`),
-    )
-  }
   if (kind !== undefined && !isLintKind(kind)) {
     return yield* Effect.fail(
       new Error(`unknown kind "${kind}"; expected one of: ${KINDS.join(", ")}`),
@@ -279,7 +255,7 @@ const program: Effect.Effect<number, Error> =
       ? rejectUnknownFlags(args.slice(1)).pipe(Effect.andThen(sessionProgram))
       : args[0] === "observe"
         ? observeProgram
-        : lintProgram.pipe(Effect.provide(WinkTaggerLive))
+        : lintProgram
 
 const handled = program.pipe(
   Effect.catch((error) =>

package/src/cli/session-command.ts

@@ -1,6 +1,10 @@
 import { resolve } from "node:path"
 import { Effect, Result } from "effect"
-import { formatFailedStatusSummary, formatStatusSummary } from "../adapter/rule-summary.ts"
+import {
+  explainRequest,
+  formatFailedStatusSummary,
+  formatStatusSummary,
+} from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
 import { loadRuleData } from "../dictionary/load.ts"
@@ -11,8 +15,9 @@ import {
   setSessionStrict,
   toggleSessionEnabled,
 } from "./session-state.ts"
+import { tryAsync } from "./try-async.ts"
 
-const USAGE = "Usage: /ase [on|off|status|strict|strict off]"
+const USAGE = "Usage: /ase [on|off|status|strict|strict off|explain]"
 
 type DictionaryState = "loaded" | "not loaded" | `failed (${string})`
 
@@ -22,28 +27,16 @@ function modeName(control: SessionControl): "disabled" | "enabled" | "strict" {
 }
 
 const readControl = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => getSessionControl(sessionId),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => getSessionControl(sessionId))
 
 const updateEnabled = (sessionId: string, enabled: boolean) =>
-  Effect.tryPromise({
-    try: () => setSessionEnabled(sessionId, enabled),
-    catch: (cause) => new Error(`cannot update session state: ${cause}`),
-  })
+  tryAsync("cannot update session state", () => setSessionEnabled(sessionId, enabled))
 
 const toggleEnabled = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => toggleSessionEnabled(sessionId),
-    catch: (cause) => new Error(`cannot update session state: ${cause}`),
-  })
+  tryAsync("cannot update session state", () => toggleSessionEnabled(sessionId))
 
 const updateStrict = (sessionId: string, strict: boolean) =>
-  Effect.tryPromise({
-    try: () => setSessionStrict(sessionId, strict),
-    catch: (cause) => new Error(`cannot update session state: ${cause}`),
-  })
+  tryAsync("cannot update session state", () => setSessionStrict(sessionId, strict))
 
 function status(sessionId: string, cwd: string): Effect.Effect<string, Error> {
   return Effect.gen(function* () {
@@ -82,6 +75,7 @@ export function runSessionCommand(args: readonly string[]): Effect.Effect<string
     )
   }
   if (command === "status") return status(sessionId, cwd)
+  if (command === "explain") return loadConfig(undefined, cwd).pipe(Effect.map(explainRequest))
   if (command === "on") {
     return updateEnabled(sessionId, true).pipe(Effect.as("Writing-rule enforcement enabled."))
   }

package/src/config/merge.ts

@@ -1,20 +1,19 @@
 import type { SteConfig } from "./schema.ts"
 
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const deepMerge = (
-  base: Record<string, unknown>,
-  over: Record<string, unknown>,
-): Record<string, unknown> => {
-  const merged = { ...base }
-  for (const [key, value] of Object.entries(over)) {
-    const existing = merged[key]
-    merged[key] =
-      isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value
-  }
-  return merged
+const mergeKey = <Key extends "rules" | "ruleDataExtensions">(
+  key: Key,
+  global: SteConfig,
+  project: SteConfig,
+): Partial<Pick<SteConfig, Key>> => {
+  const base = global[key]
+  const over = project[key]
+  if (base === undefined && over === undefined) return {}
+  return { [key]: { ...base, ...over } } as Partial<Pick<SteConfig, Key>>
 }
 
-export const mergeConfigs = (global: SteConfig, project: SteConfig): SteConfig =>
-  deepMerge(global as Record<string, unknown>, project as Record<string, unknown>) as SteConfig
+export const mergeConfigs = (global: SteConfig, project: SteConfig): SteConfig => ({
+  ...global,
+  ...project,
+  ...mergeKey("rules", global, project),
+  ...mergeKey("ruleDataExtensions", global, project),
+})

package/src/dictionary/bundled-rule-data.ts

@@ -2,13 +2,13 @@ import adjectivalParticiples from "./data/adjectival-participles.json" with { ty
 import hedging from "./data/hedging.json" with { type: "json" }
 import marketing from "./data/marketing.json" with { type: "json" }
 import phrasalVerbs from "./data/phrasal-verbs.json" with { type: "json" }
-import type { RuleData } from "./rule-data.ts"
-import { decodeDictionaryData } from "./schema.ts"
+import type { RuleDataId } from "./rule-data.ts"
+import { type Dictionary, decodeDictionaryData } from "./schema.ts"
 
 // Jiti adds a non-enumerable default property that strict schema validation rejects.
 const decodeBundledDictionary = (data: object) => decodeDictionaryData({ ...data })
 
-export const BUNDLED_RULE_DATA: RuleData = {
+export const BUNDLED_RULE_DATA: Readonly<Record<RuleDataId, Dictionary>> = {
   "phrasal-verb": decodeBundledDictionary(phrasalVerbs),
   hedging: decodeBundledDictionary(hedging),
   marketing: decodeBundledDictionary(marketing),

package/src/dictionary/load.ts

@@ -3,6 +3,7 @@ import { resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 import { Effect, Schema } from "effect"
 import { formatParseErrorIssues, type ParseError } from "../schema/parse-error.ts"
+import { BUNDLED_RULE_DATA } from "./bundled-rule-data.ts"
 import type { RuleData, RuleDataExtensions, RuleDataId } from "./rule-data.ts"
 import {
   type ApprovedWordList,
@@ -13,15 +14,6 @@ import {
 
 export const BUNDLED_DICTIONARY_PATH = fileURLToPath(new URL("./data/pi-ste.json", import.meta.url))
 
-export const BUNDLED_RULE_DATA_PATHS: Readonly<Record<RuleDataId, string>> = {
-  "phrasal-verb": fileURLToPath(new URL("./data/phrasal-verbs.json", import.meta.url)),
-  hedging: fileURLToPath(new URL("./data/hedging.json", import.meta.url)),
-  marketing: fileURLToPath(new URL("./data/marketing.json", import.meta.url)),
-  "adjectival-participle": fileURLToPath(
-    new URL("./data/adjectival-participles.json", import.meta.url),
-  ),
-}
-
 type DictionaryLoadLabel = "STE dictionary" | "rule data"
 
 export class DictionaryLoadError extends Error {
@@ -106,16 +98,17 @@ const loadExtendedRuleData = (
   id: RuleDataId,
   extensionPaths: readonly string[],
   cwd: string,
-): Effect.Effect<Dictionary, DictionaryLoadError> =>
-  Effect.all([
-    loadDictionaryData(BUNDLED_RULE_DATA_PATHS[id], "rule data"),
-    ...extensionPaths.map((path) => loadDictionaryData(resolve(cwd, path), "rule data")),
-  ]).pipe(
-    Effect.map(([bundled, ...extensions]) => ({
+): Effect.Effect<Dictionary, DictionaryLoadError> => {
+  const bundled = BUNDLED_RULE_DATA[id]
+  return Effect.all(
+    extensionPaths.map((path) => loadDictionaryData(resolve(cwd, path), "rule data")),
+  ).pipe(
+    Effect.map((extensions) => ({
       ...bundled,
       entries: [bundled, ...extensions].flatMap((dictionary) => dictionary.entries),
     })),
   )
+}
 
 export const loadRuleData = (
   extensions: RuleDataExtensions = {},

package/src/dictionary/rule-data.ts

@@ -1,12 +1,5 @@
 import type { Dictionary } from "./schema.ts"
 
-export const ruleDataIds = [
-  "phrasal-verb",
-  "hedging",
-  "marketing",
-  "adjectival-participle",
-] as const
-
-export type RuleDataId = (typeof ruleDataIds)[number]
+export type RuleDataId = "phrasal-verb" | "hedging" | "marketing" | "adjectival-participle"
 export type RuleData = Readonly<Partial<Record<RuleDataId, Dictionary>>>
 export type RuleDataExtensions = Readonly<Partial<Record<RuleDataId, readonly string[]>>>