fix: convert directoryRules' raw parse/Error throws into CliError subclasses

writeDirectoryRules called DirectoryRulesSchema.parse() directly, so a
malformed rule set (e.g. an empty path) crashed with a raw ZodError
stack trace instead of the clean message every other config-write
path in this codebase gives via ConfigValidationError. addDirectoryRule
had the same underlying problem in a different shape: it threw a bare
Error when neither --profile nor --identity was given, which also
bypasses main()'s CliError-only clean-message handling.

writeDirectoryRules now safeParses and throws ConfigValidationError,
matching readJson/applyPatch/loadConfigFile's existing pattern.
addDirectoryRule now throws a new DirectoryRuleMissingTargetError
(extends CliError) instead of a bare Error.

Author: Mearman

src/cliError.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from "vitest";
 import { CliError } from "./cliError";
 import { IdentityAlreadyExistsError, IdentityNotFoundError, InvalidIdentityNameError } from "./identityManager";
 import { InvalidCategoryNameError, ProfileAlreadyExistsError, ProfileNotFoundError } from "./configProfiles";
-import { DirectoryRuleNotFoundError } from "./directoryRules";
+import { DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError } from "./directoryRules";
 import { ForeignClaudeEntryError, UnsupportedShimSourceError } from "./claudeShim";
 import { ConfigValidationError } from "./config/load";
 import { InvalidCliCategoryError, InvalidCliEntryKeyError } from "./launcher/cliOverride";
@@ -23,6 +23,7 @@ describe("every CLI-facing error class extends CliError", () => {
     ["ProfileAlreadyExistsError", () => new ProfileAlreadyExistsError("client-acme")],
     ["InvalidCategoryNameError", () => new InvalidCategoryNameError("secret")],
     ["DirectoryRuleNotFoundError", () => new DirectoryRuleNotFoundError("/some/path")],
+    ["DirectoryRuleMissingTargetError", () => new DirectoryRuleMissingTargetError()],
     ["ForeignClaudeEntryError", () => new ForeignClaudeEntryError("/usr/local/bin/claude", "enable")],
     ["UnsupportedShimSourceError", () => new UnsupportedShimSourceError("/some/source")],
     ["ConfigValidationError", () => new ConfigValidationError("/some/config.json", [])],

src/directoryRules.test.ts

@@ -4,12 +4,15 @@ import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { buildLayoutPaths, type LayoutPaths } from "./paths";
+import { ConfigValidationError } from "./config/load";
 import {
+  DirectoryRuleMissingTargetError,
   DirectoryRuleNotFoundError,
   addDirectoryRule,
   listDirectoryRules,
   readDirectoryRules,
   removeDirectoryRule,
+  writeDirectoryRules,
 } from "./directoryRules";
 
 describe("directoryRules", () => {
@@ -55,8 +58,12 @@ describe("directoryRules", () => {
       });
     });
 
-    it("throws when neither --profile nor --identity is given", () => {
-      expect(() => addDirectoryRule(paths, "~/work", {})).toThrow(/at least one/);
+    it("throws DirectoryRuleMissingTargetError when neither --profile nor --identity is given", () => {
+      expect(() => addDirectoryRule(paths, "~/work", {})).toThrow(DirectoryRuleMissingTargetError);
+    });
+
+    it("throws ConfigValidationError, not a raw ZodError, for a rule set that fails DirectoryRulesSchema", () => {
+      expect(() => writeDirectoryRules(paths, { rules: [{ path: "" }] })).toThrow(ConfigValidationError);
     });
 
     it("appends a second rule for a different path", () => {

src/directoryRules.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 
 import { readJson, writeJsonAtomic } from "./config/store";
+import { ConfigValidationError } from "./config/load";
 import { DirectoryRulesSchema, type DirectoryRule, type DirectoryRules } from "./config/schema";
 import { CliError } from "./cliError";
 import { realPromptsPort, runProfileWizard } from "./configure";
@@ -15,15 +16,26 @@ export class DirectoryRuleNotFoundError extends CliError {
   }
 }
 
+/** Raised by `addDirectoryRule` when neither `--profile` nor `--identity` is given — a rule that pins neither would do nothing. */
+export class DirectoryRuleMissingTargetError extends CliError {
+  constructor() {
+    super("A directory rule must set at least one of --profile or --identity.");
+    this.name = "DirectoryRuleMissingTargetError";
+  }
+}
+
 /** Reads `~/.claude-use/directory-rules.json`, or an empty rule set when the file does not exist yet. */
 export function readDirectoryRules(paths: LayoutPaths): DirectoryRules {
   return readJson(paths.directoryRulesFile, DirectoryRulesSchema) ?? { rules: [] };
 }
 
-/** Validates and writes the whole `~/.claude-use/directory-rules.json` file. Exported so `src/configure.ts` can update a single rule's `categories`/`entries` in place without duplicating this validate-then-write step. */
+/** Validates and writes the whole `~/.claude-use/directory-rules.json` file. Exported so `src/configure.ts` can update a single rule's `categories`/`entries` in place without duplicating this validate-then-write step. Throws `ConfigValidationError` when `rules` fails `DirectoryRulesSchema`, rather than letting the underlying `ZodError` escape as an unhandled crash. */
 export function writeDirectoryRules(paths: LayoutPaths, rules: DirectoryRules): void {
-  const validated = DirectoryRulesSchema.parse(rules);
-  writeJsonAtomic(paths.directoryRulesFile, validated);
+  const parsed = DirectoryRulesSchema.safeParse(rules);
+  if (!parsed.success) {
+    throw new ConfigValidationError(paths.directoryRulesFile, parsed.error.issues);
+  }
+  writeJsonAtomic(paths.directoryRulesFile, parsed.data);
 }
 
 /** Lists every directory rule, in file order. */
@@ -44,7 +56,7 @@ export interface AddDirectoryRuleOptions {
  */
 export function addDirectoryRule(paths: LayoutPaths, rulePath: string, options: AddDirectoryRuleOptions): DirectoryRule {
   if (options.configProfile === undefined && options.identity === undefined) {
-    throw new Error("A directory rule must set at least one of --profile or --identity.");
+    throw new DirectoryRuleMissingTargetError();
   }
   const current = readDirectoryRules(paths);
   const existingIndex = current.rules.findIndex((rule) => rule.path === rulePath);