agent-simple-english 0.5.0 → 0.6.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.0",
+      "version": "0.6.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.0",
+  "version": "0.6.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

@@ -80,6 +80,7 @@ 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. |
 
 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.
@@ -360,7 +361,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,13 @@
 ---
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-simple-english",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Technical and house-style English lint engine, CLI, and host adapters",
   "license": "MIT",
   "type": "module",
@@ -54,7 +54,6 @@
     "micromark-util-html-tag-name": "^2.0.1",
     "micromark-util-normalize-identifier": "^2.0.1",
     "micromark-util-types": "^2.0.2",
-    "unicode-case-folding": "^1.1.1",
     "wink-eng-lite-web-model": "^1.8.1",
     "wink-nlp": "^2.4.0"
   },

package/src/adapter/feedback.ts

@@ -2,7 +2,6 @@ import type { RuleId } from "../engine/rules/registry.ts"
 import type { Violation } from "../engine/types.ts"
 
 function suggestedFix(violation: Violation): string {
-  if (violation.suggestion !== undefined) return `Use "${violation.suggestion}".`
   if (violation.suggestions !== undefined && violation.suggestions.length > 0) {
     return `Use one of these approved alternatives: ${violation.suggestions.map((item) => `"${item}"`).join(", ")}.`
   }
@@ -39,3 +38,12 @@ export function formatViolations(
 ): string {
   return `${heading} ${path}:\n${violationDetails(violations)}`
 }
+
+export function splitViolations<V extends Violation>(
+  violations: readonly V[],
+): { readonly hard: V[]; readonly soft: V[] } {
+  return {
+    hard: violations.filter((violation) => violation.severity === "hard"),
+    soft: violations.filter((violation) => violation.severity === "soft"),
+  }
+}

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

@@ -3,7 +3,7 @@ import { open, readFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { Cause, Effect } from "effect"
 import { blankCommitMetadata, findCommitInvocations } from "../adapter/commit-message.ts"
-import { formatViolations } from "../adapter/feedback.ts"
+import { formatViolations, splitViolations } from "../adapter/feedback.ts"
 import { ruleSummary } from "../adapter/rule-summary.ts"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.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,
@@ -24,6 +23,7 @@ import {
   hasProcessedReply,
   setReplyFeedback,
 } from "./session-state.ts"
+import { tryAsync } from "./try-async.ts"
 
 interface CommonEvent {
   readonly cwd: string
@@ -244,49 +244,13 @@ function proposedEdit(
 }
 
 const readEditFile = (path: string) =>
-  Effect.tryPromise({
-    try: () => readFile(path, "utf8"),
-    catch: (cause) => new Error(`cannot read edit file ${path}: ${cause}`),
-  })
+  tryAsync(`cannot read edit file ${path}`, () => readFile(path, "utf8"))
 
 interface AssistantReply {
   readonly identity: string
   readonly text: string
 }
 
-function assistantReply(line: string, path: string, offset: number): AssistantReply | undefined {
-  let value: unknown
-  try {
-    value = JSON.parse(line) as unknown
-  } catch {
-    return undefined
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined
-  const entry = value as Record<string, unknown>
-  if (entry.type !== "assistant") return undefined
-  const message = record(entry.message, "assistant transcript message")
-  const content = message.content
-  if (!Array.isArray(content)) {
-    throw new Error(`assistant transcript message in ${path} must contain content blocks`)
-  }
-  const uuid = entry.uuid
-  const identity =
-    typeof uuid === "string" && uuid.length > 0
-      ? `uuid:${uuid}`
-      : `offset:${offset}:${createHash("sha256").update(line).digest("hex")}`
-  const text = content
-    .filter(
-      (block): block is { type: "text"; text: string } =>
-        typeof block === "object" &&
-        block !== null &&
-        (block as Record<string, unknown>).type === "text" &&
-        typeof (block as Record<string, unknown>).text === "string",
-    )
-    .map((block) => block.text)
-    .join("\n")
-  return { identity, text }
-}
-
 const TRANSCRIPT_CHUNK_SIZE = 64 * 1024
 const TRANSCRIPT_ENTRY_HEADER_SIZE = 64 * 1024
 
@@ -384,23 +348,6 @@ async function readTranscriptRange(
   return buffer
 }
 
-async function assistantReplyInRange(
-  file: Awaited<ReturnType<typeof open>>,
-  path: string,
-  start: number,
-  end: number,
-): Promise<AssistantReply | undefined> {
-  const length = end - start
-  const headerLength = Math.min(length, TRANSCRIPT_ENTRY_HEADER_SIZE)
-  const header = await readTranscriptRange(file, path, start, headerLength)
-  if (transcriptEntryKind(header.toString("utf8")) !== "assistant") return undefined
-  const line =
-    headerLength === length
-      ? header.toString("utf8")
-      : (await readTranscriptRange(file, path, start, length)).toString("utf8")
-  return assistantReply(line, path, start)
-}
-
 async function turnIdentityInRange(
   file: Awaited<ReturnType<typeof open>>,
   path: string,
@@ -464,12 +411,6 @@ async function latestTranscriptEntry<T>(
   }
 }
 
-async function assistantReplyFromTranscript(path: string): Promise<AssistantReply> {
-  const reply = await latestTranscriptEntry(path, assistantReplyInRange)
-  if (reply !== undefined) return reply
-  throw new Error(`cannot find an assistant reply in ${path}`)
-}
-
 async function assistantReplyFromEvent(text: string, path: string): Promise<AssistantReply> {
   const turnIdentity = await latestTranscriptEntry(path, turnIdentityInRange)
   if (turnIdentity === undefined) throw new Error(`cannot find a reply turn in ${path}`)
@@ -477,45 +418,28 @@ async function assistantReplyFromEvent(text: string, path: string): Promise<Assi
   return { identity: `${turnIdentity}:reply:${textHash}`, text }
 }
 
-const readAssistantReply = (path: string) =>
-  Effect.tryPromise({
-    try: () => assistantReplyFromTranscript(path),
-    catch: (cause) => new Error(`cannot read assistant reply from ${path}: ${cause}`),
-  })
-
 const readEventAssistantReply = (text: string, path: string) =>
-  Effect.tryPromise({
-    try: () => assistantReplyFromEvent(text, path),
-    catch: (cause) => new Error(`cannot read assistant reply turn from ${path}: ${cause}`),
-  })
+  tryAsync(`cannot read assistant reply turn from ${path}`, () =>
+    assistantReplyFromEvent(text, path),
+  )
 
 const replyWasProcessed = (sessionId: string, replyIdentity: string) =>
-  Effect.tryPromise({
-    try: () => hasProcessedReply(sessionId, replyIdentity),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => hasProcessedReply(sessionId, replyIdentity))
 
 const updateReplyFeedback = (
   sessionId: string,
   replyIdentity: string,
   feedback: string | undefined,
 ) =>
-  Effect.tryPromise({
-    try: () => setReplyFeedback(sessionId, replyIdentity, feedback),
-    catch: (cause) => new Error(`cannot update session state: ${cause}`),
-  })
+  tryAsync("cannot update session state", () =>
+    setReplyFeedback(sessionId, replyIdentity, feedback),
+  )
 
 const takePendingFeedback = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => consumePendingFeedback(sessionId),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => consumePendingFeedback(sessionId))
 
 const readSessionControl = (sessionId: string) =>
-  Effect.tryPromise({
-    try: () => getSessionControl(sessionId),
-    catch: (cause) => new Error(`cannot read session state: ${cause}`),
-  })
+  tryAsync("cannot read session state", () => getSessionControl(sessionId))
 
 const loadLintOptions = (cwd: string, tagger: Tagger) =>
   Effect.gen(function* () {
@@ -532,16 +456,6 @@ const loadLintOptions = (cwd: string, tagger: Tagger) =>
     return { ...config, dictionary, ruleData, tagger } satisfies LintOptions
   })
 
-function splitViolations(violations: readonly ReportViolation[]): {
-  readonly hard: ReportViolation[]
-  readonly soft: ReportViolation[]
-} {
-  return {
-    hard: violations.filter((violation) => violation.severity === "hard"),
-    soft: violations.filter((violation) => violation.severity === "soft"),
-  }
-}
-
 type EvaluationObservation = Omit<ObservationDraft, "sessionId" | "cwd">
 
 interface HookEvaluation {
@@ -603,15 +517,18 @@ function textDecision(
 
 function evaluateReply(event: StopEvent, tagger: Tagger): Effect.Effect<HookEvaluation, Error> {
   return Effect.gen(function* () {
-    const reply = yield* event.lastAssistantMessage === undefined
-      ? readAssistantReply(event.transcriptPath)
-      : readEventAssistantReply(event.lastAssistantMessage, event.transcriptPath)
+    if (event.lastAssistantMessage === undefined) {
+      return yield* Effect.fail(
+        new Error(`last_assistant_message was not provided for ${event.transcriptPath}`),
+      )
+    }
+    const reply = yield* readEventAssistantReply(event.lastAssistantMessage, event.transcriptPath)
     if (yield* replyWasProcessed(event.sessionId, reply.identity)) {
       return { output: {} as Record<string, never> }
     }
     const options = yield* loadLintOptions(event.cwd, tagger)
     const violations = lint("prose-file", reply.text, options).violations
-    const hard = violations.filter((violation) => violation.severity === "hard")
+    const { hard } = splitViolations(violations)
     const feedback =
       hard.length === 0
         ? undefined
@@ -720,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))),
@@ -729,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>),
@@ -747,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,17 +1,20 @@
 #!/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"
 import { loadConfig } from "../config/load.ts"
 import { loadConfiguredDictionary } from "../dictionary/configured.ts"
 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",
@@ -32,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("--"))
@@ -102,7 +88,6 @@ interface FileViolation {
   readonly suggestions?: readonly string[]
   readonly line: number
   readonly column: number
-  readonly suggestion?: string
 }
 
 interface CliReport {
@@ -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 }[],
@@ -138,7 +122,7 @@ const toCliReport = (
     violations,
     summary: {
       total: violations.length,
-      hard: violations.filter((violation) => violation.severity === "hard").length,
+      hard: splitViolations(violations).hard.length,
     },
     skipped,
   }
@@ -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/observation-log.ts

@@ -3,6 +3,7 @@ import { mkdir, open, readdir, readFile } from "node:fs/promises"
 import { join } from "node:path"
 import { createInterface } from "node:readline"
 import type { LintKind, ReportViolation } from "../engine/types.ts"
+import { isFileError } from "../fs-error.ts"
 import { applicationStateDirectory } from "./state-directory.ts"
 
 export type ObservationEvent = "write" | "edit" | "commit-message" | "reply"
@@ -56,12 +57,6 @@ const observationsDirectory = (): string => join(applicationStateDirectory(), "o
 
 const verdictsPath = (): string => join(applicationStateDirectory(), "verdicts.jsonl")
 
-function isFileError(cause: unknown, code: string): boolean {
-  return (
-    typeof cause === "object" && cause !== null && (cause as NodeJS.ErrnoException).code === code
-  )
-}
-
 async function appendJsonLine(path: string, value: unknown): Promise<void> {
   await mkdir(applicationStateDirectory(), { recursive: true, mode: 0o700 })
   const file = await open(path, "a", 0o600)