expandai 0.0.4 → 0.0.5

package/build/dts/Init/StandardAdapters.d.ts

@@ -1,42 +0,0 @@
-import { FileSystem } from '@effect/platform';
-import { Effect } from 'effect';
-import { CodexMcp } from '../Install/Codex/Mcp.js';
-import { CodexSkill } from '../Install/Codex/Skill.js';
-import { CursorMcp } from '../Install/Cursor/Mcp.js';
-import { CursorSkill } from '../Install/Cursor/Skill.js';
-import { OpencodeHook } from '../Install/Opencode/Hook.js';
-import { OpencodeMcp } from '../Install/Opencode/Mcp.js';
-import { OpencodeSkill } from '../Install/Opencode/Skill.js';
-import { HarnessConfigurationError, type HarnessInspection, HarnessInspectionError } from './HarnessAdapter.js';
-declare const CursorAdapter_base: Effect.Service.Class<CursorAdapter, "@expandai/cli/Init/CursorAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<CursorMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CursorSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, CursorMcp | CursorSkill>;
-}>;
-export declare class CursorAdapter extends CursorAdapter_base {
-}
-declare const CodexAdapter_base: Effect.Service.Class<CodexAdapter, "@expandai/cli/Init/CodexAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<CodexMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<CodexSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, CodexMcp | CodexSkill>;
-}>;
-export declare class CodexAdapter extends CodexAdapter_base {
-}
-declare const OpencodeAdapter_base: Effect.Service.Class<OpencodeAdapter, "@expandai/cli/Init/OpencodeAdapter", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<OpencodeHook, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeMcp, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<OpencodeSkill, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-        readonly inspect: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessInspectionError, never>;
-        readonly configure: (scope: "global" | "project") => Effect.Effect<HarnessInspection, HarnessConfigurationError, never>;
-    }, never, FileSystem.FileSystem | OpencodeHook | OpencodeMcp | OpencodeSkill>;
-}>;
-export declare class OpencodeAdapter extends OpencodeAdapter_base {
-}
-export {};
-//# sourceMappingURL=StandardAdapters.d.ts.map

package/build/dts/Init/StandardAdapters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StandardAdapters.d.ts","sourceRoot":"","sources":["../../../src/Init/StandardAdapters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAG5D,OAAO,EAAE,yBAAyB,EAAE,KAAK,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;;;;;;;;;AAoD/G,qBAAa,aAAc,SAAQ,kBAuBjC;CAAG;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAuBhC;CAAG;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBA0BnC;CAAG"}

package/build/dts/Init/Status.d.ts

@@ -1,149 +0,0 @@
-import { DateTime, Effect, Schema } from 'effect';
-import { PendingInitStore } from '../Auth/PendingInit.js';
-import { ConfigManager } from '../Config.js';
-import { HarnessRegistry } from './HarnessRegistry.js';
-declare const StatusRequest_base: Schema.Class<StatusRequest, {
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-}, Schema.Struct.Encoded<{
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-}>, never, {
-    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-} & {
-    readonly scope: "global" | "project";
-}, {}, {}>;
-export declare class StatusRequest extends StatusRequest_base {
-}
-declare const StatusResult_base: Schema.Class<StatusResult, {
-    schemaVersion: Schema.Literal<[1]>;
-    status: Schema.Literal<["ok"]>;
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-    cli: Schema.Struct<{
-        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
-    }>;
-    auth: Schema.Struct<{
-        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
-        healthy: typeof Schema.Boolean;
-    }>;
-    pendingAuthorization: Schema.Union<[Schema.Struct<{
-        state: Schema.Literal<["none"]>;
-        count: Schema.Literal<[0]>;
-    }>, Schema.Struct<{
-        state: Schema.Literal<["approval_pending"]>;
-        count: Schema.Literal<[1]>;
-        approvalExpiresAt: typeof Schema.DateTimeUtc;
-    }>]>;
-    installation: Schema.Struct<{
-        configured: typeof Schema.Boolean;
-        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
-        components: Schema.Struct<{
-            webfetchHook: typeof Schema.Boolean;
-            runtimeSkill: typeof Schema.Boolean;
-            mcp: typeof Schema.Boolean;
-        }>;
-        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
-        reloadState: Schema.Literal<["not_required", "required"]>;
-        consentState: Schema.Literal<["not_required", "may_be_required"]>;
-        policyState: Schema.Literal<["unverified", "blocked"]>;
-        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
-    }>;
-}, Schema.Struct.Encoded<{
-    schemaVersion: Schema.Literal<[1]>;
-    status: Schema.Literal<["ok"]>;
-    harness: Schema.Literal<["claude-code", "cursor", "opencode", "codex"]>;
-    scope: Schema.Literal<["project", "global"]>;
-    cli: Schema.Struct<{
-        version: Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>;
-    }>;
-    auth: Schema.Struct<{
-        state: Schema.Literal<["absent", "unusable", "refresh_required", "healthy"]>;
-        healthy: typeof Schema.Boolean;
-    }>;
-    pendingAuthorization: Schema.Union<[Schema.Struct<{
-        state: Schema.Literal<["none"]>;
-        count: Schema.Literal<[0]>;
-    }>, Schema.Struct<{
-        state: Schema.Literal<["approval_pending"]>;
-        count: Schema.Literal<[1]>;
-        approvalExpiresAt: typeof Schema.DateTimeUtc;
-    }>]>;
-    installation: Schema.Struct<{
-        configured: typeof Schema.Boolean;
-        integrationVersion: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.String>>>>;
-        components: Schema.Struct<{
-            webfetchHook: typeof Schema.Boolean;
-            runtimeSkill: typeof Schema.Boolean;
-            mcp: typeof Schema.Boolean;
-        }>;
-        runtimeState: Schema.Literal<["unverified", "reload_required", "blocked"]>;
-        reloadState: Schema.Literal<["not_required", "required"]>;
-        consentState: Schema.Literal<["not_required", "may_be_required"]>;
-        policyState: Schema.Literal<["unverified", "blocked"]>;
-        policyCodes: Schema.filter<Schema.Array$<Schema.Literal<["managed_policy_blocked", "target_read_only"]>>>;
-    }>;
-}>, never, {
-    readonly auth: {
-        readonly state: "absent" | "healthy" | "refresh_required" | "unusable";
-        readonly healthy: boolean;
-    };
-} & {
-    readonly cli: {
-        readonly version: string;
-    };
-} & {
-    readonly harness: "claude-code" | "codex" | "cursor" | "opencode";
-} & {
-    readonly installation: {
-        readonly configured: boolean;
-        readonly integrationVersion?: string | undefined;
-        readonly components: {
-            readonly webfetchHook: boolean;
-            readonly runtimeSkill: boolean;
-            readonly mcp: boolean;
-        };
-        readonly runtimeState: "blocked" | "reload_required" | "unverified";
-        readonly reloadState: "not_required" | "required";
-        readonly consentState: "may_be_required" | "not_required";
-        readonly policyState: "blocked" | "unverified";
-        readonly policyCodes: readonly ("managed_policy_blocked" | "target_read_only")[];
-    };
-} & {
-    readonly pendingAuthorization: {
-        readonly state: "none";
-        readonly count: 0;
-    } | {
-        readonly state: "approval_pending";
-        readonly count: 1;
-        readonly approvalExpiresAt: DateTime.Utc;
-    };
-} & {
-    readonly schemaVersion: 1;
-} & {
-    readonly scope: "global" | "project";
-} & {
-    readonly status: "ok";
-}, {}, {}>;
-export declare class StatusResult extends StatusResult_base {
-}
-export declare const StatusServiceErrorCode: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
-declare const StatusServiceError_base: Schema.TaggedErrorClass<StatusServiceError, "StatusServiceError", {
-    readonly _tag: Schema.tag<"StatusServiceError">;
-} & {
-    code: Schema.Literal<["credential_config_malformed", "credential_storage_insecure", "credential_health_failed", "pending_state_malformed", "pending_state_unavailable", "harness_inspection_failed", "invalid_status_result"]>;
-    recoverable: typeof Schema.Boolean;
-}>;
-export declare class StatusServiceError extends StatusServiceError_base {
-    get message(): "Credential storage is not secure enough to inspect." | "Local diagnostics returned an invalid result." | "Pending authorization state could not be inspected safely." | "Pending authorization state is malformed." | "Stored credential configuration is malformed." | "Stored credentials could not be inspected safely." | "The harness configuration could not be inspected safely.";
-}
-declare const StatusService_base: Effect.Service.Class<StatusService, "@expandai/cli/Init/StatusService", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<PendingInitStore, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<HarnessRegistry, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, import("@effect/platform/FileSystem").FileSystem>];
-    readonly effect: Effect.Effect<{
-        readonly run: (request: StatusRequest) => Effect.Effect<StatusResult, StatusServiceError, never>;
-    }, never, ConfigManager | HarnessRegistry | PendingInitStore>;
-}>;
-export declare class StatusService extends StatusService_base {
-}
-export {};
-//# sourceMappingURL=Status.d.ts.map

package/build/dts/Init/Status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Status.d.ts","sourceRoot":"","sources":["../../../src/Init/Status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,EAAE,aAAa,EAA+D,MAAM,cAAc,CAAA;AAKzG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;;;;;;;;;;;;AAKtD,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCL,qBAAa,YAAa,SAAQ,iBAShC;CAAG;AAEL,eAAO,MAAM,sBAAsB,0NAQlC,CAAA;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;IACD,IAAI,OAAO,8XAiBV;CACD;;;;;;;AAoGD,qBAAa,aAAc,SAAQ,kBAqDjC;CAAG"}

package/build/dts/Install/Claude/Hook.d.ts

@@ -1,88 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { type CliCommand, ConfigIo } from '../Domain.js';
-/** Claude Code WebFetch hook invocation persisted in harness settings. */
-export declare const HOOK_INVOCATION = "expandai hook claude-code";
-export declare const HOOK_COMMAND = "expandai hook claude-code";
-/**
- * The hook line for a resolved CLI. Defaults to the bare `expandai` command;
- * when the CLI is not on PATH — an `npx expandai init` with no global install —
- * `CliInvocation` resolves to the npx form and the written hook stays runnable.
- */
-export declare function hookCommandFor(cli?: CliCommand): string;
-export declare const WEBFETCH_MATCHER = "WebFetch";
-export declare const HookCommandEntry: Schema.TypeLiteral<{
-    type: Schema.Literal<["command"]>;
-    command: typeof Schema.String;
-    expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-    /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-    expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-export declare const HookMatcher: Schema.TypeLiteral<{
-    matcher: Schema.optional<typeof Schema.String>;
-    hooks: Schema.Array$<Schema.TypeLiteral<{
-        type: Schema.Literal<["command"]>;
-        command: typeof Schema.String;
-        expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-        /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-        expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-declare const HooksSection: Schema.TypeLiteral<{
-    PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
-        matcher: Schema.optional<typeof Schema.String>;
-        hooks: Schema.Array$<Schema.TypeLiteral<{
-            type: Schema.Literal<["command"]>;
-            command: typeof Schema.String;
-            expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-            /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-            expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>;
-export declare const SettingsSchema: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.TypeLiteral<{
-    hooks: Schema.optionalWith<Schema.TypeLiteral<{
-        PreToolUse: Schema.optional<Schema.Array$<Schema.TypeLiteral<{
-            matcher: Schema.optional<typeof Schema.String>;
-            hooks: Schema.Array$<Schema.TypeLiteral<{
-                type: Schema.Literal<["command"]>;
-                command: typeof Schema.String;
-                expandaiProfileVersion: Schema.optional<typeof Schema.String>;
-                /** Whether this install added the `WebFetch` deny rule — see `makeExpandaiMatcher`. */
-                expandaiManagedDeny: Schema.optional<typeof Schema.Boolean>;
-            }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-        }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
-        default: () => typeof HooksSection.Type;
-    }>;
-    permissions: Schema.optional<Schema.TypeLiteral<{
-        deny: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
-export interface ClaudeHookPlan {
-    readonly changed: boolean;
-    readonly settings: typeof SettingsSchema.Type;
-}
-export declare function isExpandaiHookCommand(command: string): boolean;
-declare const ClaudeHook_base: Effect.Service.Class<ClaudeHook, "@expandai/cli/Install/Claude/Hook", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (_scope: "global" | "project") => Effect.Effect<void, never, never>;
-        readonly uninstall: (_scope: "global" | "project") => Effect.Effect<void, never, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, never>;
-}>;
-/**
- * Nothing here writes to `settings.json`, and nothing here removes from it.
- *
- * 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 declare class ClaudeHook extends ClaudeHook_base {
-}
-export {};
-//# sourceMappingURL=Hook.d.ts.map

package/build/dts/Install/Claude/Hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/D,OAAO,EAAE,KAAK,UAAU,EAAE,QAAQ,EAA+B,MAAM,cAAc,CAAA;AAGrF,0EAA0E;AAC1E,eAAO,MAAM,eAAe,8BAA8B,CAAA;AAC1D,eAAO,MAAM,YAAY,8BAAkB,CAAA;AAG3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,MAAM,CAEnE;AACD,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,eAAO,MAAM,gBAAgB;;;;IAK3B,uFAAuF;;0EAIxF,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;QANtB,uFAAuF;;;0EAYxF,CAAA;AAED,QAAA,MAAM,YAAY;;;;;;;YAdhB,uFAAuF;;;;0EAiBxF,CAAA;AAOD,eAAO,MAAM,cAAc;;;;;;;;gBAxBzB,uFAAuF;;;;;uBA2BpB,OAAO,YAAY,CAAC,IAAI;;;;;2EAM5F,CAAA;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,cAAc,CAAC,IAAI,CAAA;CAC7C;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAW9D;;;;;;;;;AAED;;;;;;;;;;GAUG;AAEH,qBAAa,UAAW,SAAQ,eAgC9B;CAAG"}

package/build/dts/Install/Claude/Mcp.d.ts

@@ -1,48 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { type CliCommand, ConfigIo, McpParseError, McpServersConfigSchema, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}, Schema.Struct.Encoded<{
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly type: "stdio";
-}, {}, {}>;
-/** Claude Code MCP descriptor stored under the Expand-owned server key. */
-export declare class Entry extends Entry_base {
-}
-export interface ClaudeMcpPlan {
-    readonly changed: boolean;
-    readonly config: typeof McpServersConfigSchema.Type;
-}
-/** Claude execs the descriptor directly, so `command`/`args` stay separate. */
-export declare function claudeMcpEntry(cli?: CliCommand): Entry;
-export declare const CLAUDE_MCP_ENTRY: Entry;
-export declare function planClaudeMcp(config: typeof McpServersConfigSchema.Type, cli?: CliCommand): ClaudeMcpPlan;
-export declare function planClaudeMcpRemoval(config: typeof McpServersConfigSchema.Type): ClaudeMcpPlan;
-declare const ClaudeMcp_base: Effect.Service.Class<ClaudeMcp, "@expandai/cli/Install/Claude/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, ConfigIo>;
-}>;
-export declare class ClaudeMcp extends ClaudeMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Claude/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EACN,KAAK,UAAU,EACf,QAAQ,EAER,aAAa,EACb,sBAAsB,EACtB,aAAa,EAEb,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGrB,2EAA2E;AAC3E,qBAAa,KAAM,SAAQ,UAKzB;CAAG;AAEL,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,CAAA;CACnD;AAID,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,GAAG,GAAE,UAAuB,GAAG,KAAK,CAOlE;AAED,eAAO,MAAM,gBAAgB,OAAmB,CAAA;AAqBhD,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAE,UAAuB,GAAG,aAAa,CAUrH;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC,IAAI,GAAG,aAAa,CAM9F;;;;;;;;;;AAED,qBAAa,SAAU,SAAQ,cAiD7B;CAAG"}

package/build/dts/Install/Claude/Skill.d.ts

@@ -1,23 +0,0 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
-export declare const SKILL_NAME = "expandai";
-export declare const SKILL_FILE_NAME = "SKILL.md";
-export interface ClaudeSkillPlan {
-    readonly changed: boolean;
-    readonly text: string;
-}
-export declare function renderClaudeSkill(source: string, profileVersion?: string): string;
-export declare function planClaudeSkill(current: string | undefined, source: string, profileVersion?: string): ClaudeSkillPlan;
-declare const ClaudeSkill_base: Effect.Service.Class<ClaudeSkill, "@expandai/cli/Install/Claude/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-        readonly source: () => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-    }, import("@effect/platform/Error").BadArgument | import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
-}>;
-export declare class ClaudeSkill extends ClaudeSkill_base {
-}
-export {};
-//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Install/Claude/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAI9C,eAAO,MAAM,UAAU,aAAa,CAAA;AACpC,eAAO,MAAM,eAAe,aAAa,CAAA;AAGzC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,GAAE,MAAoB,GAAG,MAAM,CAK9F;AAED,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,MAAoB,GAClC,eAAe,CAGjB;;;;;;;;;;AA2CD,qBAAa,WAAY,SAAQ,gBAG/B;CAAG"}

package/build/dts/Install/Codex/Mcp.d.ts

@@ -1,45 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-    enabled: typeof Schema.Boolean;
-}, Schema.Struct.Encoded<{
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-    enabled: typeof Schema.Boolean;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly enabled: boolean;
-}, {}, {}>;
-export declare class Entry extends Entry_base {
-}
-declare const CodexMcp_base: Effect.Service.Class<CodexMcp, "@expandai/cli/Install/Codex/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError | import("@effect/platform/Error").PlatformError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError | import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
-}>;
-/**
- * Codex MCP descriptor — Codex stores MCP servers in TOML config under
- * `[mcp_servers.<name>]`.
- *
- *   - global  → `~/.codex/config.toml`
- *   - project → `<cwd>/.codex/config.toml`
- */
-export declare class CodexMcp extends CodexMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Codex/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGhG,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAgBL;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aA+E5B;CAAG"}

package/build/dts/Install/Codex/Skill.d.ts

@@ -1,22 +0,0 @@
-import { Effect } from 'effect';
-import { SkillIo } from '../Domain.js';
-/**
- * Codex skills use the open agent skills locations:
- *
- *   - global  → `~/.agents/skills/<name>/`
- *   - project → `<cwd>/.agents/skills/<name>/`
- */
-export declare const SKILL_NAME = "expandai";
-declare const CodexSkill_base: Effect.Service.Class<CodexSkill, "@expandai/cli/Install/Codex/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, SkillIo>;
-}>;
-export declare class CodexSkill extends CodexSkill_base {
-}
-export {};
-//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Install/Codex/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Codex/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;GAKG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,UAAW,SAAQ,eA6B9B;CAAG"}

package/build/dts/Install/Cursor/Mcp.d.ts

@@ -1,45 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { CliInvocation, ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
-declare const Entry_base: Schema.Class<Entry, {
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}, Schema.Struct.Encoded<{
-    type: Schema.Literal<["stdio"]>;
-    command: typeof Schema.NonEmptyTrimmedString;
-    args: Schema.Array$<typeof Schema.String>;
-    env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-}>, never, {
-    readonly env?: {
-        readonly [x: string]: string;
-    } | undefined;
-} & {
-    readonly args: readonly string[];
-} & {
-    readonly command: string;
-} & {
-    readonly type: "stdio";
-}, {}, {}>;
-/**
- * Cursor MCP descriptor — same `mcpServers` shape as Claude Code, different
- * paths.
- *
- *   - global  → `~/.cursor/mcp.json`
- *   - project → `<cwd>/.cursor/mcp.json`
- */
-export declare class Entry extends Entry_base {
-}
-declare const CursorMcp_base: Effect.Service.Class<CursorMcp, "@expandai/cli/Install/Cursor/Mcp", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ConfigIo, never, never>, import("effect/Layer").Layer<CliInvocation, import("effect/ConfigError").ConfigError, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<void, McpParseError | McpWriteError, never>;
-        readonly isInstalled: (scope: "global" | "project") => Effect.Effect<boolean, McpParseError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, CliInvocation | ConfigIo>;
-}>;
-export declare class CursorMcp extends CursorMcp_base {
-}
-export {};
-//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Install/Cursor/Mcp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGxH;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cAiE7B;CAAG"}

package/build/dts/Install/Cursor/Skill.d.ts

@@ -1,29 +0,0 @@
-import { Effect } from 'effect';
-import { SkillIo } from '../Domain.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 declare const SKILL_NAME = "expandai";
-declare const CursorSkill_base: Effect.Service.Class<CursorSkill, "@expandai/cli/Install/Cursor/Skill", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<SkillIo, import("@effect/platform/Error").BadArgument, never>];
-    readonly effect: Effect.Effect<{
-        readonly install: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly uninstall: (scope: "global" | "project") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
-        readonly isCurrent: (scope: "global" | "project") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError, never>;
-        readonly pathFor: (scope: "global" | "project") => Effect.Effect<string, never, never>;
-    }, import("effect/ConfigError").ConfigError, SkillIo>;
-}>;
-export declare class CursorSkill extends CursorSkill_base {
-}
-export {};
-//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Install/Cursor/Skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../src/Install/Cursor/Skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAS,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,UAAU,aAAa,CAAA;;;;;;;;;;AAEpC,qBAAa,WAAY,SAAQ,gBA6B/B;CAAG"}