expandai 0.0.3 → 0.0.4

package/src/Install/Claude/Hook.ts

@@ -1,6 +1,5 @@
 import { homedir } from 'node:os'
-import { Array, Config, Console, Effect, Match, Schema } from 'effect'
-import { CLI_VERSION } from '../../Version.js'
+import { Config, Console, Effect, Match, Schema } from 'effect'
 import { type CliCommand, ConfigIo, cliShellCommand, DIRECT_CLI } from '../Domain.js'
 import type { InstallScope } from '../Mcp.js'
 
@@ -78,142 +77,20 @@ export function isExpandaiHookCommand(command: string): boolean {
 }
 
 /**
- * `expandaiManagedDeny` records whether *we* added `WebFetch` to
- * `permissions.deny`, so uninstall can tell our entry from an identical one the
- * user set first. A deny entry is a bare string with nowhere to carry that, and
- * "our hook is present" is not the same claim: installing over a settings file
- * that already denied `WebFetch` leaves the hook without us having written the
- * rule, and removing it then revokes a control its owner chose.
- */
-export function makeExpandaiMatcher(
-	profileVersion: string,
-	cli: CliCommand = DIRECT_CLI,
-	managedDeny = true,
-): typeof HookMatcher.Type {
-	return {
-		matcher: WEBFETCH_MATCHER,
-		hooks: [
-			{
-				type: 'command',
-				command: hookCommandFor(cli),
-				expandaiProfileVersion: profileVersion,
-				expandaiManagedDeny: managedDeny,
-			},
-		],
-	}
-}
-
-/** True only when our own hook entry says we wrote the deny rule. */
-export function expandaiOwnsWebFetchDeny(settings: typeof SettingsSchema.Type): boolean {
-	return (settings.hooks.PreToolUse ?? []).some((entry) =>
-		entry.hooks.some((hook) => isExpandaiHookCommand(hook.command) && hook.expandaiManagedDeny === true),
-	)
-}
-
-function webFetchAlreadyDenied(settings: typeof SettingsSchema.Type): boolean {
-	return (settings.permissions?.deny ?? []).includes(WEBFETCH_MATCHER)
-}
-
-export const expandaiMatcher = makeExpandaiMatcher(CLI_VERSION)
-
-function stripExpandaiHooks(entries: ReadonlyArray<typeof HookMatcher.Type>): Array<typeof HookMatcher.Type> {
-	return Array.flatMap(entries, (entry) => {
-		const hooks = Array.filter(entry.hooks, (hook) => !isExpandaiHookCommand(hook.command))
-		return hooks.length === 0 && hooks.length !== entry.hooks.length ? [] : [{ ...entry, hooks }]
-	})
-}
-
-/**
- * Denying `WebFetch` removes it from the toolset rather than blocking it per call,
- * so the agent reaches for Expand's tool instead of being refused. That difference
- * is the whole point: a hook can only answer a WebFetch call with `deny`, which
- * Claude Code renders to the user as `Error:` on every single fetch.
- *
- * The hook stays installed as the fallback. With the deny rule in force WebFetch is
- * never called, so the hook never fires; if the rule is ever absent or overridden,
- * the hook still intercepts — with the red line, but correctly.
- */
-export function planClaudeWebFetchDeny(settings: typeof SettingsSchema.Type): ClaudeHookPlan {
-	const deny = settings.permissions?.deny ?? []
-	if (deny.includes(WEBFETCH_MATCHER)) return { changed: false, settings }
-	return {
-		changed: true,
-		settings: {
-			...settings,
-			permissions: { ...(settings.permissions ?? {}), deny: [...deny, WEBFETCH_MATCHER] },
-		},
-	}
-}
-
-/**
- * Drops the `WebFetch` entry; anything else the user denied is left alone.
+ * Nothing here writes to `settings.json`, and nothing here removes from it.
  *
- * A deny entry is a bare string with nowhere to record who wrote it, so this
- * cannot tell our rule from an identical one the user added themselves. The
- * caller supplies that evidence — see `uninstall`.
+ * A `WebFetch` deny entry is a bare string with nowhere to record who wrote it,
+ * and our hook is not proof either: `hook install` used to write the hook on its
+ * own, so a settings file carrying our hook and a `WebFetch` deny may well hold a
+ * rule the user added afterwards. Removing it would revoke a restriction its
+ * owner chose. Since Claude Code no longer gets a hook or a deny rule from us,
+ * there is nothing of ours left to clean up, and guessing is the only thing a
+ * cleanup pass could do.
  */
-export function planClaudeWebFetchDenyRemoval(settings: typeof SettingsSchema.Type): ClaudeHookPlan {
-	const deny = settings.permissions?.deny
-	if (deny === undefined || !deny.includes(WEBFETCH_MATCHER)) return { changed: false, settings }
-	const remaining = deny.filter((entry) => entry !== WEBFETCH_MATCHER)
-	const permissions = { ...settings.permissions, deny: remaining }
-	return { changed: true, settings: { ...settings, permissions } }
-}
-
-export function planClaudeHook(
-	settings: typeof SettingsSchema.Type,
-	profileVersion: string = CLI_VERSION,
-	cli: CliCommand = DIRECT_CLI,
-): ClaudeHookPlan {
-	const preToolUse = settings.hooks.PreToolUse ?? []
-	const owned = preToolUse.flatMap((entry) =>
-		entry.hooks.filter((hook) => isExpandaiHookCommand(hook.command)).map((hook) => ({ entry, hook })),
-	)
-	// The marker records history — did *this* install add the rule — so once it is
-	// written it must be preserved, not recomputed. Recomputing it from present
-	// state makes the plan disagree with what it just wrote: after we add the deny
-	// rule, `webFetchAlreadyDenied` is true, so a second plan would decide the rule
-	// was never ours and rewrite the hook forever.
-	const existingMarker = owned[0]?.hook.expandaiManagedDeny
-	const managedDeny = existingMarker ?? !webFetchAlreadyDenied(settings)
-	const current =
-		owned.length === 1 &&
-		owned[0]?.entry.matcher === WEBFETCH_MATCHER &&
-		owned[0]?.hook.command === hookCommandFor(cli) &&
-		owned[0]?.hook.expandaiProfileVersion === profileVersion &&
-		owned[0]?.hook.expandaiManagedDeny === managedDeny
-	if (current) return { changed: false, settings }
-
-	return {
-		changed: true,
-		settings: {
-			...settings,
-			hooks: {
-				...settings.hooks,
-				PreToolUse: [...stripExpandaiHooks(preToolUse), makeExpandaiMatcher(profileVersion, cli, managedDeny)],
-			},
-		},
-	}
-}
-
-export function planClaudeHookRemoval(settings: typeof SettingsSchema.Type): ClaudeHookPlan {
-	const preToolUse = settings.hooks.PreToolUse ?? []
-	const changed = preToolUse.some((entry) => entry.hooks.some((hook) => isExpandaiHookCommand(hook.command)))
-	return changed
-		? {
-				changed,
-				settings: {
-					...settings,
-					hooks: { ...settings.hooks, PreToolUse: stripExpandaiHooks(preToolUse) },
-				},
-			}
-		: { changed, settings }
-}
 
 export class ClaudeHook extends Effect.Service<ClaudeHook>()('@expandai/cli/Install/Claude/Hook', {
 	dependencies: [ConfigIo.Default],
 	effect: Effect.gen(function* () {
-		const io = yield* ConfigIo
 		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
 		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
 
@@ -225,60 +102,20 @@ export class ClaudeHook extends Effect.Service<ClaudeHook>()('@expandai/cli/Inst
 			)
 		})
 
-		const install = Effect.fn('ClaudeHook.install')(function* (scope: InstallScope) {
-			const target = yield* pathFor(scope)
-			const settings = yield* io.read(target, SettingsSchema)
-			// Both halves, exactly as `init` writes them. This used to install the hook
-			// alone, which left the deny rule to `init` only — and made `uninstall`'s
-			// ownership rule false: it treats our hook as evidence that we wrote the
-			// deny entry, so a rule the user added after a bare `hook install` was
-			// deleted as if it were ours.
-			const hookPlan = planClaudeHook(settings)
-			const plan = planClaudeWebFetchDeny(hookPlan.settings)
-			if (!hookPlan.changed && !plan.changed) {
-				yield* Console.log(`expandai WebFetch hook already installed at ${target}`)
-				return
-			}
-			yield* io.write(target, plan.settings, SettingsSchema)
-			yield* Console.log(`Installed expandai WebFetch hook and deny rule at ${target}`)
+		const NOTICE =
+			'expandai does not install a WebFetch hook for Claude Code — the MCP server and runtime skill replace it, and neither can disable a built-in tool.'
+
+		/**
+		 * Kept as a no-op rather than deleted so `hook install|uninstall claude-code`
+		 * still resolves. Both say what the profile is instead of touching
+		 * `settings.json`, which expandai no longer writes for Claude Code.
+		 */
+		const install = Effect.fn('ClaudeHook.install')(function* (_scope: InstallScope) {
+			yield* Console.log(NOTICE)
 		})
 
-		const uninstall = Effect.fn('ClaudeHook.uninstall')(function* (scope: InstallScope) {
-			const target = yield* pathFor(scope)
-			if (!(yield* io.exists(target))) return
-			const settings = yield* io.read(target, SettingsSchema)
-			// Uninstall has to undo both halves, or `WebFetch` stays denied with nothing
-			// left to serve the fetch — worse than never having installed us.
-			//
-			// But only the halves we wrote. `expandaiManagedDeny` on our hook records
-			// whether this install added the deny rule; without it, the rule is either
-			// the user's own or from an install predating the marker, and those are
-			// indistinguishable. Guessing "ours" revokes a control its owner chose;
-			// guessing "theirs" leaves `WebFetch` denied with nothing serving fetches.
-			// So leave it and say so — `uninstall` also fans out over both scopes, and
-			// would otherwise reach into a global settings file a project-scoped
-			// install never touched.
-			const hookPlan = planClaudeHookRemoval(settings)
-			if (!hookPlan.changed) return
-			// Read the marker off the hook before it is stripped.
-			const owned = expandaiOwnsWebFetchDeny(settings)
-			const denyPlan = owned ? planClaudeWebFetchDenyRemoval(hookPlan.settings) : hookPlan
-			const strandedDeny = !owned && (settings.permissions?.deny ?? []).includes(WEBFETCH_MATCHER)
-			yield* io.write(target, denyPlan.settings, SettingsSchema)
-			// `denyPlan` is the hook plan itself when we do not own the rule, so its
-			// `changed` flag reports the hook removal — not a deny removal that never
-			// happened.
-			const removedDeny = owned && denyPlan.changed
-			yield* Console.log(
-				removedDeny
-					? `Removed expandai WebFetch hook and deny rule from ${target}`
-					: `Removed expandai WebFetch hook from ${target}`,
-			)
-			if (strandedDeny) {
-				yield* Console.log(
-					`Left "WebFetch" in permissions.deny at ${target} — expandai could not confirm it added that rule. Remove it by hand if you want Claude Code's built-in WebFetch back.`,
-				)
-			}
+		const uninstall = Effect.fn('ClaudeHook.uninstall')(function* (_scope: InstallScope) {
+			yield* Console.log(NOTICE)
 		})
 
 		return { install, uninstall, pathFor } as const

package/src/Version.ts

@@ -1,3 +1,3 @@
 // Single source of truth for the CLI version. Keep in sync with package.json —
 // the compiled binary cannot read package.json at runtime.
-export const CLI_VERSION = '0.0.3'
+export const CLI_VERSION = '0.0.4'