expandai 0.0.0 → 0.0.2

package/src/Hook/Opencode.ts

@@ -0,0 +1,58 @@
+import { NodeStream } from '@effect/platform-node'
+import { Console, Effect, Schema, String } from 'effect'
+import { ApiClient } from '../ApiClient.js'
+import { MarkdownUnavailable } from '../Commands/Fetch.js'
+import { HookProtocolFailed, StdinReadError } from './Errors.js'
+import { withSnapshotNote } from './SnapshotNote.js'
+
+/**
+ * Runner for `expandai hook opencode`. Reads `{ url }` from stdin (sent by
+ * the OpenCode plugin), fetches via expand.ai, and writes `{ markdown }`
+ * to stdout for the plugin to splice back into webfetch's result.
+ */
+
+class ProtocolInput extends Schema.Class<ProtocolInput>('OpencodeWebfetchInput')({
+	url: Schema.String,
+}) {}
+
+const decodeProtocolInput = Schema.decode(Schema.parseJson(ProtocolInput))
+const encodeProtocolOutput = Schema.encode(Schema.parseJson(Schema.Unknown))
+
+const readStdin = NodeStream.toString(() => process.stdin, {
+	onFailure: (error) => new StdinReadError({ error }),
+	encoding: 'utf8',
+})
+
+export class OpencodeHook extends Effect.Service<OpencodeHook>()('@expandai/cli/Hook/Opencode', {
+	dependencies: [ApiClient.Default],
+	effect: Effect.gen(function* () {
+		const apiClient = yield* ApiClient
+
+		const runProtocol = Effect.fn('OpencodeHook.runProtocol')(function* () {
+			const raw = yield* readStdin.pipe(Effect.mapError((error) => new HookProtocolFailed({ error })))
+			const payload = yield* decodeProtocolInput(raw).pipe(
+				Effect.mapError((error) => new HookProtocolFailed({ error })),
+			)
+			const url = payload.url
+
+			yield* Effect.gen(function* () {
+				// Object mode (`/v1/fetch/json`) over markdown mode so the response carries
+				// `meta.snapshotId` — the handle the agent uses to search this same capture
+				// via `fetch_search` instead of fetching the URL again. The note rides inside
+				// `markdown`, so the installed plugin needs no protocol change.
+				const result = yield* apiClient.fetchFetchResult({
+					params: {},
+					payload: { url, include: { markdown: true } },
+				})
+				if (String.isEmpty(result.markdown)) {
+					return yield* new MarkdownUnavailable({ url })
+				}
+
+				const markdown = withSnapshotNote(result.markdown, result.meta.snapshotId, result.meta.playground)
+				yield* Console.log(yield* encodeProtocolOutput({ markdown }))
+			}).pipe(Effect.mapError((error) => new HookProtocolFailed({ error, url })))
+		})
+
+		return { runProtocol } as const
+	}),
+}) {}

package/src/Hook/SnapshotNote.ts

@@ -0,0 +1,18 @@
+import { String } from 'effect'
+
+/**
+ * Prepends a short note to fetched markdown carrying the snapshot handle and the public
+ * playground link, and telling the agent how to search the already-captured page by handle
+ * (rather than fetching the URL again) and cite specific passages back to the user. Both the
+ * Claude Code and OpenCode hooks inject this so the surfaced guidance stays identical.
+ */
+export function withSnapshotNote(markdown: string, snapshotId: string, playgroundUrl: string): string {
+	const note = String.stripMargin(`
+		|> Fetched via expand.ai (snapshot \`${snapshotId}\`). View or share this capture at
+		|> ${playgroundUrl}
+		|> To extract specific passages, search the snapshot by handle — call the \`fetch_search\`
+		|> tool with \`snapshotId: "${snapshotId}"\`, or run \`expandai search ${snapshotId} "<query>"\`.
+		|> Each snippet returns a \`citationUrl\` you can hand the user to audit the exact source.
+		|> Do not fetch this URL again.`)
+	return `${note}\n\n---\n\n${markdown}`
+}

package/src/Install/Claude/Hook.ts

@@ -0,0 +1,133 @@
+import { homedir } from 'node:os'
+import { Array, Config, Console, Effect, Match, Schema } from 'effect'
+import { ConfigIo } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * Claude Code hook config — `~/.claude/settings.json` (global) or
+ * `<cwd>/.claude/settings.json` (project). PreToolUse hooks fire on built-in
+ * tools; we register the WebFetch matcher to route to `expandai hook claude-code`.
+ */
+
+export const HOOK_COMMAND = 'expandai hook claude-code'
+export const WEBFETCH_MATCHER = 'WebFetch'
+
+export const HookCommandEntry = Schema.Struct({
+	type: Schema.Literal('command'),
+	command: Schema.String,
+})
+
+export const HookMatcher = Schema.Struct({
+	matcher: Schema.optional(Schema.String),
+	hooks: Schema.Array(HookCommandEntry),
+})
+
+const HooksSection = Schema.Struct(
+	{ PreToolUse: Schema.optional(Schema.Array(HookMatcher)) },
+	Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+)
+
+export const SettingsSchema = Schema.parseJson(
+	Schema.Struct(
+		{ hooks: Schema.optionalWith(HooksSection, { default: () => ({}) as typeof HooksSection.Type }) },
+		Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+	),
+	{ space: 2 },
+)
+
+export const expandaiMatcher = {
+	matcher: WEBFETCH_MATCHER,
+	hooks: [{ type: 'command' as const, command: HOOK_COMMAND }],
+}
+
+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()))
+
+		const pathFor = Effect.fn(function* (scope: Scope) {
+			return yield* Match.value(scope).pipe(
+				Match.when('global', () => Effect.succeed(`${home}/.claude/settings.json`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.claude/settings.json`)),
+				Match.exhaustive,
+			)
+		})
+
+		const install = Effect.fn('ClaudeHook.install')(function* (scope: Scope) {
+			const target = yield* pathFor(scope)
+			const settings = yield* io.read(target, SettingsSchema)
+
+			const preToolUse = settings.hooks.PreToolUse ?? []
+			const alreadyInstalled = preToolUse.some(
+				(entry) => entry.matcher === WEBFETCH_MATCHER && entry.hooks.some((hook) => hook.command === HOOK_COMMAND),
+			)
+
+			if (alreadyInstalled) {
+				yield* Console.log(`expandai WebFetch hook already installed at ${target}`)
+				return
+			}
+
+			yield* io.write(
+				target,
+				{
+					...settings,
+					hooks: {
+						...settings.hooks,
+						PreToolUse: [...preToolUse, expandaiMatcher],
+					},
+				},
+				SettingsSchema,
+			)
+			yield* Console.log(`Installed expandai WebFetch hook at ${target}`)
+		})
+
+		const uninstall = Effect.fn('ClaudeHook.uninstall')(function* (scope: Scope) {
+			const target = yield* pathFor(scope)
+			const exists = yield* io.exists(target)
+			if (!exists) {
+				return
+			}
+
+			const settings = yield* io.read(target, SettingsSchema)
+			const preToolUse = settings.hooks.PreToolUse ?? []
+			const updatedPreToolUse = Array.filter(
+				Array.map(preToolUse, (entry) => ({
+					...entry,
+					hooks: Array.filter(entry.hooks, (hook) => hook.command !== HOOK_COMMAND),
+				})),
+				(entry) => entry.matcher !== WEBFETCH_MATCHER || entry.hooks.length > 0,
+			)
+
+			// Compare total hook-command count rather than outer-array length:
+			// our HOOK_COMMAND can sit alongside other hooks in a shared matcher
+			// entry (e.g. a user merged it in by hand), in which case the entry
+			// stays after filtering but the inner hook count drops.
+			const countCommands = Effect.fn(function* (entries: typeof preToolUse) {
+				return Array.reduce(entries, 0, (n, entry) => n + entry.hooks.length)
+			})
+
+			const before = yield* countCommands(preToolUse)
+			const after = yield* countCommands(updatedPreToolUse)
+			if (before === after) {
+				return
+			}
+
+			yield* io.write(
+				target,
+				{
+					...settings,
+					hooks: {
+						...settings.hooks,
+						PreToolUse: updatedPreToolUse,
+					},
+				},
+				SettingsSchema,
+			)
+			yield* Console.log(`Removed expandai WebFetch hook from ${target}`)
+		})
+
+		return { install, uninstall } as const
+	}),
+}) {}

package/src/Install/Claude/Mcp.ts

@@ -0,0 +1,82 @@
+import { homedir } from 'node:os'
+import { Config, Console, Effect, Match, Record, Schema } from 'effect'
+import { ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError, SERVER_KEY } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * Claude Code MCP descriptor — `mcpServers` shape (de facto Claude Desktop
+ * convention; also read by Cursor and other clients).
+ *
+ *   - global  → `~/.claude.json`        (Claude Code's user-scope store)
+ *   - project → `<cwd>/.mcp.json`       (the agent-agnostic project file)
+ */
+export class Entry extends Schema.Class<Entry>('ClaudeMcpEntry')({
+	type: Schema.Literal('stdio'),
+	command: Schema.NonEmptyTrimmedString,
+	args: Schema.Array(Schema.String),
+	env: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+}) {}
+
+export class ClaudeMcp extends Effect.Service<ClaudeMcp>()('@expandai/cli/Install/Claude/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}/.claude.json`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.mcp.json`)),
+				Match.exhaustive,
+			)
+		})
+
+		const readConfig = Effect.fn(function* (file: string) {
+			return yield* io
+				.read(file, McpServersConfigSchema)
+				.pipe(Effect.mapError((error) => new McpParseError({ path: file, error })))
+		})
+
+		const writeConfig = Effect.fn(function* (file: string, value: unknown) {
+			yield* io
+				.write(file, value, McpServersConfigSchema)
+				.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,
+				mcpServers: {
+					...config.mcpServers,
+					[SERVER_KEY]: new Entry({
+						type: 'stdio',
+						command: 'expandai',
+						args: ['mcp', 'run'],
+					}),
+				},
+			})
+			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.mcpServers)) {
+				return
+			}
+			yield* writeConfig(file, { ...config, mcpServers: Record.remove(config.mcpServers, 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.mcpServers
+		})
+
+		return { install, uninstall, isInstalled, pathFor } as const
+	}),
+}) {}

package/src/Install/Claude/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'
+
+/**
+ * Claude Code skills live under `<scope>/.claude/skills/<name>/SKILL.md`.
+ *
+ *   - global  → `~/.claude/skills/expandai/SKILL.md`
+ *   - project → `<cwd>/.claude/skills/expandai/SKILL.md`
+ *
+ * (Globally-scoped Claude Code skills are also reachable via `npx skills`,
+ * but file-copy gives us a uniform install path with OpenCode and works
+ * without npm.)
+ */
+
+export const SKILL_NAME = 'expandai'
+
+export class ClaudeSkill extends Effect.Service<ClaudeSkill>()('@expandai/cli/Install/Claude/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}/.claude/skills/${SKILL_NAME}`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.claude/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/Codex/Mcp.ts

@@ -0,0 +1,109 @@
+import { homedir } from 'node:os'
+import { Config, Console, Effect, Match, Record, Schema } from 'effect'
+import { parse, stringify, type TomlTableWithoutBigInt } from 'smol-toml'
+import { ConfigIo, McpParseError, McpWriteError, SERVER_KEY } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+export class Entry extends Schema.Class<Entry>('CodexMcpEntry')({
+	command: Schema.NonEmptyTrimmedString,
+	args: Schema.Array(Schema.String),
+	enabled: Schema.Boolean,
+}) {}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+const getMcpServers = Effect.fn(function* (config: TomlTableWithoutBigInt) {
+	const servers = config.mcp_servers
+	return isRecord(servers) ? servers : {}
+})
+
+function toStringifyValue(value: TomlTableWithoutBigInt) {
+	// smol-toml's stringify type accepts any; keep the unsafe boundary local.
+	return value as unknown as Record<string, unknown>
+}
+
+/**
+ * Codex MCP descriptor — Codex stores MCP servers in TOML config under
+ * `[mcp_servers.<name>]`.
+ *
+ *   - global  → `~/.codex/config.toml`
+ *   - project → `<cwd>/.codex/config.toml`
+ */
+export class CodexMcp extends Effect.Service<CodexMcp>()('@expandai/cli/Install/Codex/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}/.codex/config.toml`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.codex/config.toml`)),
+				Match.exhaustive,
+			)
+		})
+
+		const readConfig = Effect.fn(function* (file: string) {
+			const text = yield* io.readText(file)
+			return yield* Effect.try({
+				try: () => parse(text, { integersAsBigInt: false }),
+				catch: (error) => new McpParseError({ path: file, error }),
+			})
+		})
+
+		const writeConfig = Effect.fn(function* (file: string, value: TomlTableWithoutBigInt) {
+			const encoded = yield* Effect.try({
+				try: () => stringify(toStringifyValue(value)),
+				catch: (error) => new McpWriteError({ path: file, error }),
+			})
+			yield* io.writeText(file, encoded).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)
+			const servers = yield* getMcpServers(config)
+
+			const entryModel = new Entry({
+				command: 'expandai',
+				args: ['mcp', 'run'],
+				enabled: true,
+			})
+
+			const entry: TomlTableWithoutBigInt = {
+				command: entryModel.command,
+				args: [...entryModel.args],
+				enabled: entryModel.enabled,
+			}
+
+			yield* writeConfig(file, {
+				...config,
+				mcp_servers: Record.set(servers, SERVER_KEY, entry),
+			})
+			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)
+			const servers = yield* getMcpServers(config)
+			if (!(SERVER_KEY in servers)) {
+				return
+			}
+			yield* writeConfig(file, { ...config, mcp_servers: Record.remove(servers, 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)
+			const servers = yield* getMcpServers(config)
+			return SERVER_KEY in servers
+		})
+
+		return { install, uninstall, isInstalled, pathFor } as const
+	}),
+}) {}

package/src/Install/Codex/Skill.ts

@@ -0,0 +1,40 @@
+import { homedir } from 'node:os'
+import { Config, Effect, Match } from 'effect'
+import { SkillIo } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * Codex skills use the open agent skills locations:
+ *
+ *   - global  → `~/.agents/skills/<name>/`
+ *   - project → `<cwd>/.agents/skills/<name>/`
+ */
+
+export const SKILL_NAME = 'expandai'
+
+export class CodexSkill extends Effect.Service<CodexSkill>()('@expandai/cli/Install/Codex/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}/.agents/skills/${SKILL_NAME}`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.agents/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/Cursor/Mcp.ts

@@ -0,0 +1,82 @@
+import { homedir } from 'node:os'
+import { Config, Console, Effect, Match, Record, Schema } from 'effect'
+import { ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError, SERVER_KEY } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * Cursor MCP descriptor — same `mcpServers` shape as Claude Code, different
+ * paths.
+ *
+ *   - global  → `~/.cursor/mcp.json`
+ *   - project → `<cwd>/.cursor/mcp.json`
+ */
+export class Entry extends Schema.Class<Entry>('CursorMcpEntry')({
+	type: Schema.Literal('stdio'),
+	command: Schema.NonEmptyTrimmedString,
+	args: Schema.Array(Schema.String),
+	env: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+}) {}
+
+export class CursorMcp extends Effect.Service<CursorMcp>()('@expandai/cli/Install/Cursor/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}/.cursor/mcp.json`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.cursor/mcp.json`)),
+				Match.exhaustive,
+			)
+		})
+
+		const readConfig = Effect.fn(function* (file: string) {
+			return yield* io
+				.read(file, McpServersConfigSchema)
+				.pipe(Effect.mapError((error) => new McpParseError({ path: file, error })))
+		})
+
+		const writeConfig = Effect.fn(function* (file: string, value: unknown) {
+			yield* io
+				.write(file, value, McpServersConfigSchema)
+				.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,
+				mcpServers: {
+					...config.mcpServers,
+					[SERVER_KEY]: new Entry({
+						type: 'stdio',
+						command: 'expandai',
+						args: ['mcp', 'run'],
+					}),
+				},
+			})
+			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.mcpServers)) {
+				return
+			}
+			yield* writeConfig(file, { ...config, mcpServers: Record.remove(config.mcpServers, 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.mcpServers
+		})
+
+		return { install, uninstall, isInstalled, pathFor } as const
+	}),
+}) {}

package/src/Install/Cursor/Skill.ts

@@ -0,0 +1,47 @@
+import { homedir } from 'node:os'
+import { Config, Effect, Match } from 'effect'
+import { SkillIo } from '../Domain.js'
+import type { Scope } from '../Mcp.js'
+
+/**
+ * Cursor skills are auto-loaded from these locations (per
+ * cursor.com/docs/skills):
+ *
+ *   - global  → `~/.cursor/skills/<name>/`
+ *   - project → `<cwd>/.cursor/skills/<name>/`
+ *
+ * Cursor also compat-loads `.claude/skills/`, `.codex/skills/`, `.agents/skills/`
+ * at both project and user scope, but we ship to Cursor's native paths.
+ *
+ * Format is the same SKILL.md + YAML frontmatter open standard as Claude Code
+ * and OpenCode, so the bundled `skills/expandai/` directory copies in unchanged.
+ */
+
+export const SKILL_NAME = 'expandai'
+
+export class CursorSkill extends Effect.Service<CursorSkill>()('@expandai/cli/Install/Cursor/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}/.cursor/skills/${SKILL_NAME}`)),
+				Match.when('project', () => Effect.succeed(`${cwd}/.cursor/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
+	}),
+}) {}