expandai 0.0.0 → 0.0.2

package/src/Install/Domain.ts

@@ -0,0 +1,148 @@
+import { FileSystem, Path } from '@effect/platform'
+import { NodeFileSystem, NodePath } from '@effect/platform-node'
+import { Effect, Inspectable, Schema } from 'effect'
+
+export class McpParseError extends Schema.TaggedError<McpParseError>()('McpParseError', {
+	path: Schema.String,
+	error: Schema.Defect,
+}) {
+	get message() {
+		return `Failed to parse MCP config at ${this.path}: ${Inspectable.format(this.error)}`
+	}
+}
+
+export class McpWriteError extends Schema.TaggedError<McpWriteError>()('McpWriteError', {
+	path: Schema.String,
+	error: Schema.Defect,
+}) {
+	get message() {
+		return `Failed to write MCP config at ${this.path}: ${Inspectable.format(this.error)}`
+	}
+}
+
+export const Host = Schema.Literal('claude-code', 'cursor', 'opencode', 'codex')
+export type Host = typeof Host.Type
+
+export const Scope = Schema.Literal('project', 'global')
+export type Scope = typeof Scope.Type
+
+const McpServerMap = Schema.Record({ key: Schema.String, value: Schema.Unknown })
+
+export const McpServersConfigSchema = Schema.parseJson(
+	Schema.Struct({ mcpServers: Schema.optionalWith(McpServerMap, { default: () => ({}) }) }, McpServerMap),
+	{ space: 2 },
+)
+
+export const OpencodeConfigSchema = Schema.parseJson(
+	Schema.Struct({ mcp: Schema.optionalWith(McpServerMap, { default: () => ({}) }) }, McpServerMap),
+	{ space: 2 },
+)
+
+export const SERVER_KEY = 'expandai'
+
+export const readConfigText = Effect.fn(function* (file: string) {
+	const fs = yield* FileSystem.FileSystem
+	const exists = yield* fs.exists(file)
+	if (!exists) {
+		return '{}'
+	}
+	return yield* fs.readFileString(file)
+})
+
+export const writeConfigText = Effect.fn(function* (file: string, text: string) {
+	const fs = yield* FileSystem.FileSystem
+	const path = yield* Path.Path
+	yield* fs.makeDirectory(path.dirname(file), { recursive: true })
+	yield* fs.writeFileString(file, `${text}\n`)
+})
+
+/**
+ * Captures `FileSystem` + `Path` once and exposes string-encoded JSON read/
+ * write methods that don't re-yield them on every call. Use this from inside
+ * an `Effect.Service` gen block so the install/uninstall methods don't have
+ * to re-thread `provideService` calls.
+ */
+export class ConfigIo extends Effect.Service<ConfigIo>()('@expandai/cli/Install/ConfigIo', {
+	dependencies: [NodeFileSystem.layer, NodePath.layer],
+	effect: Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem
+		const path = yield* Path.Path
+
+		const read = Effect.fn('ConfigIo.read')(function* <A>(file: string, schema: Schema.Schema<A, string>) {
+			const text = yield* readConfigText(file).pipe(Effect.provideService(FileSystem.FileSystem, fs))
+			return yield* Schema.decode(schema)(text)
+		})
+
+		const write = Effect.fn('ConfigIo.write')(function* <A>(
+			file: string,
+			value: unknown,
+			schema: Schema.Schema<A, string>,
+		) {
+			const encoded = yield* Schema.encodeUnknown(schema)(value)
+			yield* writeConfigText(file, encoded).pipe(
+				Effect.provideService(FileSystem.FileSystem, fs),
+				Effect.provideService(Path.Path, path),
+			)
+		})
+
+		const exists = Effect.fn('ConfigIo.exists')(function* (file: string) {
+			return yield* fs.exists(file)
+		})
+
+		// Raw text I/O for formats `ConfigIo.read`/`write` can't handle through a
+		// `Schema.parseJson(...)` schema (e.g. Codex's TOML). Missing file reads
+		// as an empty string — callers attach their own parser-specific default.
+		const readText = Effect.fn('ConfigIo.readText')(function* (file: string) {
+			const present = yield* fs.exists(file)
+			return present ? yield* fs.readFileString(file) : ''
+		})
+
+		const writeText = Effect.fn('ConfigIo.writeText')(function* (file: string, text: string) {
+			yield* writeConfigText(file, text).pipe(
+				Effect.provideService(FileSystem.FileSystem, fs),
+				Effect.provideService(Path.Path, path),
+			)
+		})
+
+		return { read, write, exists, readText, writeText } as const
+	}),
+}) {}
+
+/**
+ * Captures `FileSystem` + `Path` once and exposes skill directory copy/remove
+ * operations. The bundled `SKILL.md` lives at `<cli>/skills/expandai/` (or
+ * `<build>/skills/expandai/` in production); this service computes that path
+ * from its own `import.meta.url`, so per-host skill descriptors only need to
+ * provide `pathFor` and call `io.install(target)` / `io.uninstall(target)`.
+ */
+export class SkillIo extends Effect.Service<SkillIo>()('@expandai/cli/Install/SkillIo', {
+	dependencies: [NodeFileSystem.layer, NodePath.layer],
+	effect: Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem
+		const path = yield* Path.Path
+
+		const sourceDir = path.resolve(
+			path.dirname(yield* path.fromFileUrl(new URL(import.meta.url))),
+			'..',
+			'..',
+			'skills',
+			'expandai',
+		)
+
+		const install = Effect.fn('SkillIo.install')(function* (target: string) {
+			yield* fs.makeDirectory(path.dirname(target), { recursive: true })
+			yield* fs.copy(sourceDir, target, { overwrite: true })
+			return target
+		})
+
+		const uninstall = Effect.fn('SkillIo.uninstall')(function* (target: string) {
+			const exists = yield* fs.exists(target)
+			if (exists) {
+				yield* fs.remove(target, { recursive: true })
+			}
+			return target
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Hook.ts

@@ -0,0 +1,50 @@
+import { Effect, Match, Schema } from 'effect'
+import { ClaudeHook } from './Claude/Hook.js'
+import { Mcp, type Scope } from './Mcp.js'
+import { OpencodeHook } from './Opencode/Hook.js'
+
+/**
+ * Hook install dispatcher. Bundles MCP install + per-host hook config:
+ *
+ *   - claude-code: writes the matcher into `~/.claude/settings.json` (global)
+ *     or `<cwd>/.claude/settings.json` (project), then registers expandai as
+ *     an MCP server at the matching scope.
+ *   - opencode:    writes the webfetch plugin file into `.opencode/plugins/`
+ *     (project) or `~/.config/opencode/plugins/` (global), plus registers
+ *     expandai as an MCP server.
+ *
+ * Cursor has no hook system per opencode.ai/docs and Cursor's docs, so it's
+ * absent from this Host union (compare with `Mcp.Host` which includes Cursor).
+ */
+export const HookHost = Schema.Literal('claude-code', 'opencode')
+export type HookHost = typeof HookHost.Type
+
+export class HookInstaller extends Effect.Service<HookInstaller>()('@expandai/cli/Install/Hook', {
+	dependencies: [Mcp.Default, ClaudeHook.Default, OpencodeHook.Default],
+	effect: Effect.gen(function* () {
+		const mcp = yield* Mcp
+		const claudeHook = yield* ClaudeHook
+		const opencodeHook = yield* OpencodeHook
+
+		const install = Effect.fn('HookInstaller.install')(function* (host: HookHost, scope: Scope) {
+			// Bundle: MCP install first, then host-specific hook config.
+			yield* mcp.install(host, scope)
+			yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claudeHook.install(scope)),
+				Match.when('opencode', () => opencodeHook.install(scope)),
+				Match.exhaustive,
+			)
+		})
+
+		const uninstall = Effect.fn('HookInstaller.uninstall')(function* (host: HookHost, scope: Scope) {
+			yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claudeHook.uninstall(scope)),
+				Match.when('opencode', () => opencodeHook.uninstall(scope)),
+				Match.exhaustive,
+			)
+			yield* mcp.uninstall(host, scope)
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Mcp.ts

@@ -0,0 +1,71 @@
+import { Effect, Match } from 'effect'
+import { ClaudeMcp } from './Claude/Mcp.js'
+import { CodexMcp } from './Codex/Mcp.js'
+import { CursorMcp } from './Cursor/Mcp.js'
+import type { Host, Scope } from './Domain.js'
+import { OpencodeMcp } from './Opencode/Mcp.js'
+
+export { Host, McpParseError, McpWriteError, Scope } from './Domain.js'
+
+/**
+ * MCP install dispatcher. Per-host descriptors live in `Install/<Host>/Mcp.ts`
+ * and contribute their path resolution + entry shape; this service handles
+ * the file I/O (read existing config, merge, write back) and routes by host.
+ *
+ *   - claude-code (~/.claude.json | <cwd>/.mcp.json) → mcpServers shape
+ *   - cursor      (~/.cursor/mcp.json | <cwd>/.cursor/mcp.json) → mcpServers
+ *   - opencode    (~/.config/opencode/opencode.json | <cwd>/opencode.json) → opencode `mcp` shape
+ *   - codex       (~/.codex/config.toml | <cwd>/.codex/config.toml) → Codex TOML `mcp_servers`
+ */
+
+export class Mcp extends Effect.Service<Mcp>()('@expandai/cli/Install/Mcp', {
+	dependencies: [ClaudeMcp.Default, CursorMcp.Default, OpencodeMcp.Default, CodexMcp.Default],
+	effect: Effect.gen(function* () {
+		const claude = yield* ClaudeMcp
+		const cursor = yield* CursorMcp
+		const opencode = yield* OpencodeMcp
+		const codex = yield* CodexMcp
+
+		const pathFor = Effect.fn('Mcp.pathFor')(function* (host: Host, scope: Scope) {
+			return yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.pathFor(scope)),
+				Match.when('cursor', () => cursor.pathFor(scope)),
+				Match.when('opencode', () => opencode.pathFor(scope)),
+				Match.when('codex', () => codex.pathFor(scope)),
+				Match.exhaustive,
+			)
+		})
+
+		const install = Effect.fn('Mcp.install')(function* (host: Host, scope: Scope) {
+			yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.install(scope)),
+				Match.when('cursor', () => cursor.install(scope)),
+				Match.when('opencode', () => opencode.install(scope)),
+				Match.when('codex', () => codex.install(scope)),
+				Match.exhaustive,
+			)
+		})
+
+		const uninstall = Effect.fn('Mcp.uninstall')(function* (host: Host, scope: Scope) {
+			yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.uninstall(scope)),
+				Match.when('cursor', () => cursor.uninstall(scope)),
+				Match.when('opencode', () => opencode.uninstall(scope)),
+				Match.when('codex', () => codex.uninstall(scope)),
+				Match.exhaustive,
+			)
+		})
+
+		const isInstalled = Effect.fn('Mcp.isInstalled')(function* (host: Host, scope: Scope) {
+			return yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.isInstalled(scope)),
+				Match.when('cursor', () => cursor.isInstalled(scope)),
+				Match.when('opencode', () => opencode.isInstalled(scope)),
+				Match.when('codex', () => codex.isInstalled(scope)),
+				Match.exhaustive,
+			)
+		})
+
+		return { install, uninstall, isInstalled, pathFor } as const
+	}),
+}) {}

package/src/Install/Opencode/Hook.ts

@@ -0,0 +1,55 @@
+import { homedir } from 'node:os'
+import { FileSystem, Path } from '@effect/platform'
+import { NodeFileSystem, NodePath } from '@effect/platform-node'
+import { Config, Console, Effect, Match } from 'effect'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * OpenCode hook = a JS plugin file at `.opencode/plugins/` (project) or
+ * `~/.config/opencode/plugins/` (global). The plugin shells out to
+ * `expandai hook opencode` so all fetch logic stays in the CLI.
+ *
+ * The plugin uses `tool.execute.after` (the only hook whose contract lets us
+ * replace the rendered result via `output.output`); `tool.execute.before` is
+ * limited to mutating tool args. See @opencode-ai/plugin's dist/index.d.ts.
+ */
+
+export const PLUGIN_FILE = 'expandai-webfetch.js'
+
+export class OpencodeHook extends Effect.Service<OpencodeHook>()('@expandai/cli/Install/Opencode/Hook', {
+	dependencies: [NodeFileSystem.layer, NodePath.layer],
+	effect: Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem
+		const path = yield* Path.Path
+		const source = path.join(path.dirname(yield* path.fromFileUrl(new URL(import.meta.url))), PLUGIN_FILE)
+
+		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
+		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
+
+		const pathFor = Effect.fn(function* (scope: Scope) {
+			return yield* Match.value(scope).pipe(
+				Match.when('global', () => Effect.succeed(`${home}/.config/opencode/plugins/${PLUGIN_FILE}`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.opencode/plugins/${PLUGIN_FILE}`)),
+				Match.exhaustive,
+			)
+		})
+
+		const install = Effect.fn('OpencodeHook.install')(function* (scope: Scope) {
+			const target = yield* pathFor(scope)
+			yield* fs.makeDirectory(path.dirname(target), { recursive: true })
+			yield* fs.copyFile(source, target)
+			yield* Console.log(`Installed expandai webfetch plugin at ${target}`)
+		})
+
+		const uninstall = Effect.fn('OpencodeHook.uninstall')(function* (scope: Scope) {
+			const target = yield* pathFor(scope)
+			const exists = yield* fs.exists(target)
+			if (exists) {
+				yield* fs.remove(target)
+				yield* Console.log(`Removed expandai webfetch plugin from ${target}`)
+			}
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Opencode/Mcp.ts

@@ -0,0 +1,84 @@
+import { homedir } from 'node:os'
+import { Config, Console, Effect, Match, Record, Schema } from 'effect'
+import { ConfigIo, McpParseError, McpWriteError, OpencodeConfigSchema, SERVER_KEY } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * OpenCode MCP descriptor — its own shape (per opencode.ai/docs/mcp-servers):
+ * top-level key is `mcp` (not `mcpServers`), `command` is an array (no
+ * separate args), env is called `environment`, and `type` uses
+ * `local` / `remote` rather than `stdio` / `http`.
+ *
+ *   - global  → `~/.config/opencode/opencode.json`
+ *   - project → `<cwd>/opencode.json`
+ */
+export class Entry extends Schema.Class<Entry>('OpencodeMcpEntry')({
+	type: Schema.Literal('local'),
+	command: Schema.Array(Schema.String),
+	environment: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+	enabled: Schema.optional(Schema.Boolean),
+}) {}
+
+export class OpencodeMcp extends Effect.Service<OpencodeMcp>()('@expandai/cli/Install/Opencode/Mcp', {
+	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()))
+
+		const pathFor = Effect.fn(function* (scope: Scope) {
+			return yield* Match.value(scope).pipe(
+				Match.when('global', () => Effect.succeed(`${home}/.config/opencode/opencode.json`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/opencode.json`)),
+				Match.exhaustive,
+			)
+		})
+
+		const readConfig = Effect.fn(function* (file: string) {
+			return yield* io
+				.read(file, OpencodeConfigSchema)
+				.pipe(Effect.mapError((error) => new McpParseError({ path: file, error })))
+		})
+
+		const writeConfig = Effect.fn(function* (file: string, value: unknown) {
+			yield* io
+				.write(file, value, OpencodeConfigSchema)
+				.pipe(Effect.mapError((error) => new McpWriteError({ path: file, error })))
+		})
+
+		const install = Effect.fn(function* (scope: Scope) {
+			const file = yield* pathFor(scope)
+			const config = yield* readConfig(file)
+			yield* writeConfig(file, {
+				...config,
+				mcp: {
+					...config.mcp,
+					[SERVER_KEY]: new Entry({
+						type: 'local',
+						command: ['expandai', 'mcp', 'run'],
+						enabled: true,
+					}),
+				},
+			})
+			yield* Console.log(`Installed expandai MCP server into ${file}`)
+		})
+
+		const uninstall = Effect.fn(function* (scope: Scope) {
+			const file = yield* pathFor(scope)
+			const config = yield* readConfig(file)
+			if (!(SERVER_KEY in config.mcp)) {
+				return
+			}
+			yield* writeConfig(file, { ...config, mcp: Record.remove(config.mcp, SERVER_KEY) })
+			yield* Console.log(`Removed expandai MCP server from ${file}`)
+		})
+
+		const isInstalled = Effect.fn(function* (scope: Scope) {
+			const file = yield* pathFor(scope)
+			const config = yield* readConfig(file)
+			return SERVER_KEY in config.mcp
+		})
+
+		return { install, uninstall, isInstalled, pathFor } as const
+	}),
+}) {}

package/src/Install/Opencode/Skill.ts

@@ -0,0 +1,44 @@
+import { homedir } from 'node:os'
+import { Config, Effect, Match } from 'effect'
+import { SkillIo } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * OpenCode skills are Claude-Code-compatible Markdown files. Per
+ * opencode.ai/docs/skills, OpenCode auto-discovers them under either
+ * `.opencode/skills/<name>/`, `.claude/skills/<name>/`, or
+ * `.agents/skills/<name>/` (and the `~/.config/opencode/...` equivalents
+ * for global). We ship to OpenCode-native paths.
+ *
+ *   - global  → `~/.config/opencode/skills/expandai/SKILL.md`
+ *   - project → `<cwd>/.opencode/skills/expandai/SKILL.md`
+ */
+
+export const SKILL_NAME = 'expandai'
+
+export class OpencodeSkill extends Effect.Service<OpencodeSkill>()('@expandai/cli/Install/Opencode/Skill', {
+	dependencies: [SkillIo.Default],
+	effect: Effect.gen(function* () {
+		const io = yield* SkillIo
+		const home = yield* Config.string('HOME').pipe(Config.withDefault(homedir()))
+		const cwd = yield* Config.string('PWD').pipe(Config.withDefault(process.cwd()))
+
+		const pathFor = Effect.fn(function* (scope: Scope) {
+			return yield* Match.value(scope).pipe(
+				Match.when('global', () => Effect.succeed(`${home}/.config/opencode/skills/${SKILL_NAME}`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.opencode/skills/${SKILL_NAME}`)),
+				Match.exhaustive,
+			)
+		})
+
+		const install = Effect.fn(function* (scope: Scope) {
+			return yield* io.install(yield* pathFor(scope))
+		})
+
+		const uninstall = Effect.fn(function* (scope: Scope) {
+			return yield* io.uninstall(yield* pathFor(scope))
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Opencode/expandai-webfetch.d.ts

@@ -0,0 +1,23 @@
+export interface OpencodeWebfetchPluginInput {
+	readonly tool: string
+	readonly sessionID?: string
+	readonly callID?: string
+	readonly args?: {
+		readonly url?: string
+	}
+}
+
+export interface OpencodeWebfetchPluginOutput {
+	title?: string
+	output?: string
+	metadata?: unknown
+}
+
+export interface OpencodeWebfetchPluginHooks {
+	readonly 'tool.execute.after': (
+		input: OpencodeWebfetchPluginInput,
+		output: OpencodeWebfetchPluginOutput,
+	) => Promise<void>
+}
+
+export declare const ExpandaiWebfetch: () => Promise<OpencodeWebfetchPluginHooks>

package/src/Install/Opencode/expandai-webfetch.js

@@ -0,0 +1,38 @@
+// expandai OpenCode plugin - routes webfetch through the expandai CLI.
+// Generated by `expandai hook install opencode <scope>`.
+//
+// We hook `tool.execute.after` rather than `.before` because OpenCode's plugin
+// contract only lets `before` mutate args (`output.args`); replacing the
+// rendered result is only possible from `after`, where `output` is the tool
+// output object (`{ title, output, metadata }`). See @opencode-ai/plugin's
+// dist/index.d.ts.
+import { spawn } from 'node:child_process'
+
+export const ExpandaiWebfetch = async () => ({
+	'tool.execute.after': async (input, output) => {
+		if (input.tool !== 'webfetch') return
+		const url = input.args?.url
+		if (typeof url !== 'string' || url.length === 0) return
+
+		try {
+			const child = spawn('expandai', ['hook', 'opencode'], {
+				stdio: ['pipe', 'pipe', 'inherit'],
+				env: { ...process.env, EXPANDAI_CLI_CONTEXT: 'agent' },
+			})
+			child.stdin.end(JSON.stringify({ url }))
+			let stdout = ''
+			child.stdout.setEncoding('utf8')
+			for await (const chunk of child.stdout) stdout += chunk
+			const exitCode = await new Promise((resolve) => child.on('close', resolve))
+			if (exitCode !== 0 || stdout.trim().length === 0) return
+
+			const { markdown } = JSON.parse(stdout)
+			if (typeof markdown !== 'string' || markdown.length === 0) return
+
+			output.output = markdown
+			output.title = url
+		} catch (error) {
+			console.error(`expandai-webfetch plugin failed: ${error?.message ?? error}`)
+		}
+	},
+})

package/src/Install/Skill.ts

@@ -0,0 +1,57 @@
+import { Console, Effect, Match } from 'effect'
+import { ClaudeSkill } from './Claude/Skill.js'
+import { CodexSkill } from './Codex/Skill.js'
+import { CursorSkill } from './Cursor/Skill.js'
+import type { Host, Scope } from './Mcp.js'
+import { OpencodeSkill } from './Opencode/Skill.js'
+
+/**
+ * Skill install dispatcher. Copies the bundled `SKILL.md` from the CLI's
+ * own `skills/expandai/` source into the host-specific destination.
+ *
+ *   - claude-code: `~/.claude/skills/expandai/` (global) or
+ *                  `<cwd>/.claude/skills/expandai/` (project)
+ *   - cursor:      `~/.cursor/skills/expandai/` (global) or
+ *                  `<cwd>/.cursor/skills/expandai/` (project)
+ *   - opencode:    `~/.config/opencode/skills/expandai/` (global) or
+ *                  `<cwd>/.opencode/skills/expandai/` (project)
+ *   - codex:       `~/.agents/skills/expandai/` (global) or
+ *                  `<cwd>/.agents/skills/expandai/` (project)
+ *
+ * All hosts use the same `SKILL.md` + YAML frontmatter open standard,
+ * so the bundled skill directory copies in unchanged.
+ */
+
+export class Skill extends Effect.Service<Skill>()('@expandai/cli/Install/Skill', {
+	dependencies: [ClaudeSkill.Default, CursorSkill.Default, OpencodeSkill.Default, CodexSkill.Default],
+	effect: Effect.gen(function* () {
+		const claude = yield* ClaudeSkill
+		const cursor = yield* CursorSkill
+		const opencode = yield* OpencodeSkill
+		const codex = yield* CodexSkill
+
+		const install = Effect.fn('Skill.install')(function* (host: Host, scope: Scope) {
+			const target = yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.install(scope)),
+				Match.when('cursor', () => cursor.install(scope)),
+				Match.when('opencode', () => opencode.install(scope)),
+				Match.when('codex', () => codex.install(scope)),
+				Match.exhaustive,
+			)
+			yield* Console.log(`Installed expandai skill into ${target}`)
+		})
+
+		const uninstall = Effect.fn('Skill.uninstall')(function* (host: Host, scope: Scope) {
+			const target = yield* Match.value(host).pipe(
+				Match.when('claude-code', () => claude.uninstall(scope)),
+				Match.when('cursor', () => cursor.uninstall(scope)),
+				Match.when('opencode', () => opencode.uninstall(scope)),
+				Match.when('codex', () => codex.uninstall(scope)),
+				Match.exhaustive,
+			)
+			yield* Console.log(`Removed expandai skill from ${target}`)
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Uninstall.ts

@@ -0,0 +1,82 @@
+import { Array, Effect, Match, Schema } from 'effect'
+import { type HookHost, HookInstaller } from './Hook.js'
+import { Host, Mcp, Scope } from './Mcp.js'
+import { Skill } from './Skill.js'
+
+export const UninstallTarget = Schema.Literal('all', 'hook', 'skill', 'mcp')
+
+export class UninstallOptions extends Schema.Class<UninstallOptions>('UninstallOptions')({
+	target: Schema.optional(UninstallTarget),
+	host: Schema.optional(Host),
+	scope: Schema.optional(Scope),
+}) {}
+
+const SCOPES: (typeof Scope.Type)[] = ['global', 'project']
+const HOSTS: (typeof Host.Type)[] = ['claude-code', 'cursor', 'opencode', 'codex']
+
+const isHookHost = (host: typeof Host.Type): host is HookHost => host === 'claude-code' || host === 'opencode'
+
+export class Uninstall extends Effect.Service<Uninstall>()('@expandai/cli/Install/Uninstall', {
+	dependencies: [HookInstaller.Default, Mcp.Default, Skill.Default],
+	effect: Effect.gen(function* () {
+		const hook = yield* HookInstaller
+		const mcp = yield* Mcp
+		const skill = yield* Skill
+
+		const uninstall = Effect.fn(function* (options: UninstallOptions = new UninstallOptions({})) {
+			const target = options.target ?? 'all'
+			const hosts = options.host ? [options.host] : HOSTS
+			const scopes = options.scope ? [options.scope] : SCOPES
+
+			// Sequential by default: a future change that merges any two `(host,
+			// scope)` config paths into the same file shouldn't silently race.
+			// Logout/uninstall happens once per session; throughput isn't the
+			// bottleneck.
+			const uninstallHooks = Effect.fnUntraced(function* () {
+				const hookHosts = Array.filter(hosts, isHookHost)
+				yield* Effect.forEach(
+					hookHosts,
+					(host) => Effect.forEach(scopes, (scope) => hook.uninstall(host, scope), { discard: true }),
+					{ discard: true },
+				)
+			})
+
+			const uninstallSkills = Effect.fnUntraced(function* () {
+				yield* Effect.forEach(
+					hosts,
+					(host) => Effect.forEach(scopes, (scope) => skill.uninstall(host, scope), { discard: true }),
+					{ discard: true },
+				)
+			})
+
+			const uninstallMcp = Effect.fnUntraced(function* () {
+				yield* Effect.forEach(
+					hosts,
+					(host) => Effect.forEach(scopes, (scope) => mcp.uninstall(host, scope), { discard: true }),
+					{ discard: true },
+				)
+			})
+
+			const uninstallMcpWithoutHooks = Effect.fnUntraced(function* () {
+				const mcpOnlyHosts = Array.filter(hosts, (host) => !isHookHost(host))
+				yield* Effect.forEach(
+					mcpOnlyHosts,
+					(host) => Effect.forEach(scopes, (scope) => mcp.uninstall(host, scope), { discard: true }),
+					{ discard: true },
+				)
+			})
+
+			yield* Match.value(target).pipe(
+				Match.when('all', () =>
+					uninstallHooks().pipe(Effect.zipRight(uninstallMcpWithoutHooks()), Effect.zipRight(uninstallSkills())),
+				),
+				Match.when('hook', () => uninstallHooks()),
+				Match.when('skill', () => uninstallSkills()),
+				Match.when('mcp', () => uninstallMcp()),
+				Match.exhaustive,
+			)
+		})
+
+		return { uninstall } as const
+	}),
+}) {}