agent-simple-english 0.4.0 → 0.5.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.4.0",
+      "version": "0.5.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.4.0",
+  "version": "0.5.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-simple-english",
-  "version": "0.4.0",
+  "version": "0.5.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": "^3.14.0",
+    "effect": "4.0.0-rc.112",
     "micromark": "^4.0.2",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm-table": "^2.1.1",

package/src/cli/hook.ts

@@ -715,7 +715,7 @@ function recordEvaluation(event: HookEvent, evaluation: HookEvaluation): Effect.
       }),
     catch: () => undefined,
   }).pipe(
-    Effect.catchAll(() => Effect.void),
+    Effect.catch(() => Effect.void),
     Effect.as(evaluation.output),
   )
 }
@@ -760,14 +760,14 @@ export function runHookMode(raw: string): Effect.Effect<HookOutput, never, Tagge
               return yield* recordEvaluation(event, evaluation)
             })
           }),
-          Effect.catchAll((error) =>
+          Effect.catch((error) =>
             Effect.succeed(
               event.hookEventName === "PreToolUse"
                 ? nonBlockingWarning(error.message)
                 : nonBlockingError(error.message),
             ),
           ),
-          Effect.catchAllCause((cause) =>
+          Effect.catchCause((cause) =>
             Effect.succeed(
               event.hookEventName === "PreToolUse"
                 ? hookInternalFailure(cause)

package/src/cli/main.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { readFile } from "node:fs/promises"
-import { Effect, Either } from "effect"
+import { Effect, Result } from "effect"
 import packageManifest from "../../package.json" with { type: "json" }
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
@@ -164,7 +164,7 @@ const hookProgram = Effect.gen(function* () {
   console.log(JSON.stringify(output))
   return 0
 }).pipe(
-  Effect.catchAllCause((cause) =>
+  Effect.catchCause((cause) =>
     Effect.sync(() => {
       console.log(JSON.stringify(hookInternalFailure(cause)))
       return 0
@@ -220,20 +220,20 @@ const lintProgram = Effect.gen(function* () {
     )
   }
   const config = yield* loadConfig(configPath)
-  const loadedDictionary = yield* Effect.either(
+  const loadedDictionary = yield* Effect.result(
     loadConfiguredDictionary(config, process.cwd(), process.env.SIMPLE_ENGLISH_DICTIONARY),
   )
-  const loadedRuleData = yield* Effect.either(loadRuleData(config.ruleDataExtensions))
-  if (Either.isLeft(loadedDictionary) && config.approvedWordsPath !== undefined) {
-    return yield* Effect.fail(loadedDictionary.left)
+  const loadedRuleData = yield* Effect.result(loadRuleData(config.ruleDataExtensions))
+  if (Result.isFailure(loadedDictionary) && config.approvedWordsPath !== undefined) {
+    return yield* Effect.fail(loadedDictionary.failure)
   }
-  const dictionary = Either.getOrUndefined(loadedDictionary)
-  const ruleData = Either.getOrUndefined(loadedRuleData)
-  if (Either.isLeft(loadedDictionary)) {
-    yield* Effect.sync(() => console.error(loadedDictionary.left.message))
+  const dictionary = Result.getOrUndefined(loadedDictionary)
+  const ruleData = Result.getOrUndefined(loadedRuleData)
+  if (Result.isFailure(loadedDictionary)) {
+    yield* Effect.sync(() => console.error(loadedDictionary.failure.message))
   }
-  if (Either.isLeft(loadedRuleData)) {
-    yield* Effect.sync(() => console.error(loadedRuleData.left.message))
+  if (Result.isFailure(loadedRuleData)) {
+    yield* Effect.sync(() => console.error(loadedRuleData.failure.message))
   }
   const inputs =
     paths.length === 0
@@ -282,7 +282,7 @@ const program: Effect.Effect<number, Error> =
         : lintProgram.pipe(Effect.provide(WinkTaggerLive))
 
 const handled = program.pipe(
-  Effect.catchAll((error) =>
+  Effect.catch((error) =>
     Effect.sync(() => {
       console.error(error.message)
       return 2

package/src/cli/session-command.ts

@@ -1,5 +1,5 @@
 import { resolve } from "node:path"
-import { Effect, Either } from "effect"
+import { Effect, Result } from "effect"
 import { formatFailedStatusSummary, formatStatusSummary } from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
@@ -48,25 +48,25 @@ const updateStrict = (sessionId: string, strict: boolean) =>
 function status(sessionId: string, cwd: string): Effect.Effect<string, Error> {
   return Effect.gen(function* () {
     const control = yield* readControl(sessionId)
-    const configResult = yield* Effect.either(loadConfig(undefined, cwd))
-    if (Either.isLeft(configResult)) {
-      return formatFailedStatusSummary(modeName(control), configResult.left.message)
+    const configResult = yield* Effect.result(loadConfig(undefined, cwd))
+    if (Result.isFailure(configResult)) {
+      return formatFailedStatusSummary(modeName(control), configResult.failure.message)
     }
     const dictionaryPath = process.env.SIMPLE_ENGLISH_DICTIONARY
-    const dictionaryResult = yield* Effect.either(
+    const dictionaryResult = yield* Effect.result(
       Effect.all({
         dictionary: loadConfiguredDictionary(
-          configResult.right,
+          configResult.success,
           cwd,
           dictionaryPath === undefined ? undefined : resolve(cwd, dictionaryPath),
         ),
-        ruleData: loadRuleData(configResult.right.ruleDataExtensions, cwd),
+        ruleData: loadRuleData(configResult.success.ruleDataExtensions, cwd),
       }),
     )
-    const dictionary: DictionaryState = Either.isRight(dictionaryResult)
+    const dictionary: DictionaryState = Result.isSuccess(dictionaryResult)
       ? "loaded"
-      : `failed (${dictionaryResult.left.message})`
-    return formatStatusSummary(configResult.right, modeName(control), dictionary)
+      : `failed (${dictionaryResult.failure.message})`
+    return formatStatusSummary(configResult.success, modeName(control), dictionary)
   })
 }
 

package/src/config/schema.ts

@@ -1,7 +1,13 @@
-import { Effect, ParseResult, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import type { RuleDataExtensions } from "../dictionary/rule-data.ts"
 import { type RuleId, ruleIds } from "../engine/rules/registry.ts"
 import type { RuleSetting } from "../engine/types.ts"
+import {
+  formatParseErrorIssues,
+  formatParseErrorTree,
+  type ParseError,
+} from "../schema/parse-error.ts"
+import { NonEmptyTrimmedString } from "../schema/primitives.ts"
 
 export interface SteConfig {
   readonly rules?: Partial<Readonly<Record<RuleId, RuleSetting>>>
@@ -11,63 +17,53 @@ export interface SteConfig {
   readonly approvedWordsPath?: string
 }
 
-const RuleSettingSchema = Schema.Literal("hard", "soft", "off").annotations({
-  message: (issue) => ({
-    message: `must be "hard", "soft", or "off", got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
+const RuleSettingSchema = Schema.Literals(["hard", "soft", "off"]).annotate({
+  expected: '"hard", "soft", or "off"',
 })
 
-const RulesSchema = Schema.partial(
-  Schema.Struct(Object.fromEntries(ruleIds.map((id) => [id, RuleSettingSchema]))),
+const RulesSchema = Schema.Struct(
+  Object.fromEntries(ruleIds.map((id) => [id, Schema.optionalKey(RuleSettingSchema)])),
 )
 
-const MaxSentenceWordsSchema = Schema.Int.pipe(Schema.positive()).annotations({
-  message: (issue) => ({
-    message: `must be a positive integer, got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
-})
+// One refinement over Unknown, rather than Number plus two checks, so that a
+// wrong type and a wrong number both report the same text and the value.
+const MaxSentenceWordsSchema = Schema.Unknown.pipe(
+  Schema.refine(
+    (value): value is number => typeof value === "number" && Number.isInteger(value) && value > 0,
+    { expected: "a positive integer" },
+  ),
+)
 
-const ExemptBlockQuotesSchema = Schema.Boolean.annotations({
-  message: (issue) => ({
-    message: `must be a boolean, got ${JSON.stringify(issue.actual)}`,
-    override: true,
-  }),
-})
+const ExemptBlockQuotesSchema = Schema.Boolean
 
-const RuleDataExtensionsSchema = Schema.partial(
-  Schema.Struct({
-    "phrasal-verb": Schema.Array(Schema.NonEmptyTrimmedString),
-    hedging: Schema.Array(Schema.NonEmptyTrimmedString),
-    marketing: Schema.Array(Schema.NonEmptyTrimmedString),
-    "adjectival-participle": Schema.Array(Schema.NonEmptyTrimmedString),
-  }),
-)
+const RuleDataExtensionsSchema = Schema.Struct({
+  "phrasal-verb": Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  hedging: Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  marketing: Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+  "adjectival-participle": Schema.optionalKey(Schema.Array(NonEmptyTrimmedString)),
+})
 
 const SteConfigSchema = Schema.Struct({
-  rules: Schema.optional(RulesSchema),
-  maxSentenceWords: Schema.optional(MaxSentenceWordsSchema),
-  exemptBlockQuotes: Schema.optional(ExemptBlockQuotesSchema),
-  ruleDataExtensions: Schema.optional(RuleDataExtensionsSchema),
-  approvedWordsPath: Schema.optional(Schema.NonEmptyTrimmedString),
+  rules: Schema.optionalKey(RulesSchema),
+  maxSentenceWords: Schema.optionalKey(MaxSentenceWordsSchema),
+  exemptBlockQuotes: Schema.optionalKey(ExemptBlockQuotesSchema),
+  ruleDataExtensions: Schema.optionalKey(RuleDataExtensionsSchema),
+  approvedWordsPath: Schema.optionalKey(NonEmptyTrimmedString),
 })
 
-const decodeUnknown = Schema.decodeUnknown(SteConfigSchema, {
+const decodeUnknown = Schema.decodeUnknownEffect(SteConfigSchema, {
   onExcessProperty: "error",
   errors: "all",
+  // v4 omits the rejected value from an issue unless this option is on.
+  reportInput: true,
 })
 
 export class ConfigError extends Error {
   readonly _tag = "ConfigError"
 }
 
-const formatError = (error: ParseResult.ParseError, source: string): string => {
-  // Optional fields decode as `T | undefined` unions, so every failure also
-  // reports a useless "Expected undefined" branch; drop those.
-  const issues = ParseResult.ArrayFormatter.formatErrorSync(error).filter(
-    (issue) => !issue.message.startsWith("Expected undefined"),
-  )
+const formatError = (error: ParseError, source: string): string => {
+  const issues = formatParseErrorIssues(error)
   const lines = [
     ...new Set(
       issues.map(
@@ -78,7 +74,7 @@ const formatError = (error: ParseResult.ParseError, source: string): string => {
   const detail =
     lines.length > 0
       ? lines.map((line) => `  ${line}`).join("\n")
-      : `  ${ParseResult.TreeFormatter.formatErrorSync(error)}`
+      : `  ${formatParseErrorTree(error)}`
   return `invalid config in ${source}:\n${detail}`
 }
 

package/src/dictionary/load.ts

@@ -1,7 +1,8 @@
 import { readFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { fileURLToPath } from "node:url"
-import { Effect, ParseResult, Schema } from "effect"
+import { Effect, Schema } from "effect"
+import { formatParseErrorIssues, type ParseError } from "../schema/parse-error.ts"
 import type { RuleData, RuleDataExtensions, RuleDataId } from "./rule-data.ts"
 import {
   type ApprovedWordList,
@@ -34,8 +35,8 @@ export class DictionaryLoadError extends Error {
   }
 }
 
-const formatParseError = (error: ParseResult.ParseError): string => {
-  const issue = ParseResult.ArrayFormatter.formatErrorSync(error)[0]
+const formatParseError = (error: ParseError): string => {
+  const issue = formatParseErrorIssues(error)[0]
   if (issue === undefined) {
     return "invalid dictionary data"
   }
@@ -48,15 +49,15 @@ const formatParseError = (error: ParseResult.ParseError): string => {
   return path === "" ? `invalid dictionary data: ${issue.message}` : `${path}: ${issue.message}`
 }
 
-const decodeDictionary = Schema.decode(Schema.parseJson(DictionarySchema), {
-  onExcessProperty: "error",
-  errors: "all",
-})
+// v4 omits the rejected value from an issue unless reportInput is on.
+const decodeOptions = { onExcessProperty: "error", errors: "all", reportInput: true } as const
 
-const decodeApprovedWordList = Schema.decode(Schema.parseJson(ApprovedWordListSchema), {
-  onExcessProperty: "error",
-  errors: "all",
-})
+const decodeDictionary = Schema.decodeEffect(Schema.fromJsonString(DictionarySchema), decodeOptions)
+
+const decodeApprovedWordList = Schema.decodeEffect(
+  Schema.fromJsonString(ApprovedWordListSchema),
+  decodeOptions,
+)
 
 const readDictionaryFile = (
   path: string,

package/src/dictionary/schema.ts

@@ -1,25 +1,22 @@
 import { Schema } from "effect"
+import { NonEmptyTrimmedString } from "../schema/primitives.ts"
 import { DICTIONARY_FORM_PATTERN, DICTIONARY_WORD_PATTERN } from "./form.ts"
 
 const DictionarySourceSchema = Schema.Struct({
-  name: Schema.NonEmptyTrimmedString,
-  repository: Schema.NonEmptyTrimmedString,
-  commit: Schema.NonEmptyTrimmedString,
-  path: Schema.NonEmptyTrimmedString,
+  name: NonEmptyTrimmedString,
+  repository: NonEmptyTrimmedString,
+  commit: NonEmptyTrimmedString,
+  path: NonEmptyTrimmedString,
 })
 
-const DictionaryFormSchema = Schema.NonEmptyTrimmedString.pipe(
-  Schema.pattern(DICTIONARY_FORM_PATTERN),
-)
+const DictionaryFormSchema = NonEmptyTrimmedString.check(Schema.isPattern(DICTIONARY_FORM_PATTERN))
 
-const DictionaryWordSchema = Schema.NonEmptyTrimmedString.pipe(
-  Schema.pattern(DICTIONARY_WORD_PATTERN),
-)
+const DictionaryWordSchema = NonEmptyTrimmedString.check(Schema.isPattern(DICTIONARY_WORD_PATTERN))
 
 const DictionaryEntrySchema = Schema.Struct({
   unapproved: Schema.NonEmptyArray(DictionaryFormSchema),
-  suggestions: Schema.NonEmptyArray(Schema.NonEmptyTrimmedString),
-  partsOfSpeech: Schema.optional(Schema.NonEmptyArray(Schema.NonEmptyTrimmedString)),
+  suggestions: Schema.NonEmptyArray(NonEmptyTrimmedString),
+  partsOfSpeech: Schema.optional(Schema.NonEmptyArray(NonEmptyTrimmedString)),
 })
 
 export const DictionarySchema = Schema.Struct({

package/src/schema/parse-error.ts

@@ -0,0 +1,32 @@
+import { type Schema, SchemaIssue } from "effect"
+
+// This isolates the Effect v4 `SchemaIssue` formatter calls, so a later
+// Schema change touches only this file.
+
+export type ParseError = Schema.SchemaError
+
+export interface ParseErrorIssue {
+  readonly path: ReadonlyArray<string | number>
+  readonly message: string
+}
+
+const formatIssues = SchemaIssue.makeFormatterStandardSchemaV1()
+const formatTree = SchemaIssue.makeFormatterDefault()
+
+// A Standard Schema path segment is either a raw key or a `{ key }` wrapper,
+// and symbol keys never appear in this package's schemas.
+const pathSegments = (
+  path: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined,
+): ReadonlyArray<string | number> =>
+  (path ?? []).map((segment) => {
+    const key = typeof segment === "object" ? segment.key : segment
+    return typeof key === "number" ? key : String(key)
+  })
+
+export const formatParseErrorIssues = (error: ParseError): ParseErrorIssue[] =>
+  formatIssues(error.issue).issues.map((issue) => ({
+    path: pathSegments(issue.path),
+    message: issue.message,
+  }))
+
+export const formatParseErrorTree = (error: ParseError): string => formatTree(error.issue)

package/src/schema/primitives.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect"
+
+// Effect v4 has no NonEmptyTrimmedString schema.
+// Every call site imports this alias, so the definition stays in one file.
+export const NonEmptyTrimmedString = Schema.Trimmed.check(
+  Schema.isNonEmpty({ expected: "a non-empty string" }),
+)

package/src/tagger/wink.ts

@@ -31,7 +31,7 @@ export function makeWinkTagger(): Tagger {
   }
 }
 
-export class TaggerService extends Context.Tag("TaggerService")<TaggerService, Tagger>() {}
+export class TaggerService extends Context.Service<TaggerService, Tagger>()("TaggerService") {}
 
 const makeLazyWinkTagger = (): Tagger => {
   let tagger: Tagger | undefined