expandai 0.0.0 → 0.0.2

package/build/dts/Commands/Fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../../src/Commands/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,OAAO,EAAW,MAAM,aAAa,CAAA;AAE7D,OAAO,EAAW,MAAM,EAAS,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;;;;;;AAIvE,qBAAa,mBAAoB,SAAQ,wBAEvC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,mBAAoB,SAAQ,wBAGvC;IACD,IAAI,OAAO,WAEV;CACD;AAaD,eAAO,MAAM,WAAW,6DAatB,CAAA;AAmCF,UAAU,kBAAkB;IAC3B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CACzB;AAED,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,kBAAkB,CAkErF,CAAA"}

package/build/dts/Commands/Hook.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@effect/cli';
+import { ClaudeHook } from '../Hook/Claude.js';
+import { OpencodeHook } from '../Hook/Opencode.js';
+import { HookInstaller } from '../Install/Hook.js';
+export declare const HumanHookCommand: Command.Command<"hook", HookInstaller | ClaudeHook | OpencodeHook, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("../Install/Domain.js").McpParseError | import("../Install/Domain.js").McpWriteError | import("../Hook/Errors.js").HookProtocolFailed, {
+    readonly subcommand: import("effect/Option").Option<{} | {
+        readonly host: "claude-code" | "opencode";
+        readonly scope: "project" | "global";
+    } | {
+        readonly host: "claude-code" | "opencode";
+        readonly scope: "project" | "global";
+    }>;
+}>;
+export declare const AgentHookCommand: Command.Command<"hook", ClaudeHook | OpencodeHook, import("../Hook/Errors.js").HookProtocolFailed, {
+    readonly subcommand: import("effect/Option").Option<{}>;
+}>;
+//# sourceMappingURL=Hook.d.ts.map

package/build/dts/Commands/Hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../src/Commands/Hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAmClD,eAAO,MAAM,gBAAgB;;;;;;;;EAG5B,CAAA;AAED,eAAO,MAAM,gBAAgB;;EAG5B,CAAA"}

package/build/dts/Commands/Mcp.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { Mcp } from '../Install/Mcp.js';
+export declare const InstallSubCommand: Command.Command<"install", Mcp, import("@effect/platform/Error").PlatformError | import("../Install/Domain.js").McpParseError | import("../Install/Domain.js").McpWriteError, {
+    readonly host: "claude-code" | "cursor" | "opencode" | "codex";
+    readonly scope: "project" | "global";
+}>;
+export declare const UninstallSubCommand: Command.Command<"uninstall", Mcp, import("@effect/platform/Error").PlatformError | import("../Install/Domain.js").McpParseError | import("../Install/Domain.js").McpWriteError, {
+    readonly host: "claude-code" | "cursor" | "opencode" | "codex";
+    readonly scope: "project" | "global";
+}>;
+//# sourceMappingURL=Mcp.d.ts.map

package/build/dts/Commands/Mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mcp.d.ts","sourceRoot":"","sources":["../../../src/Commands/Mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAcvC,eAAO,MAAM,iBAAiB;;;EAQ7B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;EAG/B,CAAA"}

package/build/dts/Commands/McpRun.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@effect/cli';
+export declare const McpRunCommand: Command.Command<"run", never, import("effect/ConfigError").ConfigError, {
+    readonly includeDocs: boolean;
+}>;
+//# sourceMappingURL=McpRun.d.ts.map

package/build/dts/Commands/McpRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpRun.d.ts","sourceRoot":"","sources":["../../../src/Commands/McpRun.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAW,MAAM,aAAa,CAAA;AAU9C,eAAO,MAAM,aAAa;;EAazB,CAAA"}

package/build/dts/Commands/Search.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@effect/cli';
+import { Schema } from 'effect';
+declare const SnapshotSnippetsUnavailable_base: Schema.TaggedErrorClass<SnapshotSnippetsUnavailable, "SnapshotSnippetsUnavailable", {
+    readonly _tag: Schema.tag<"SnapshotSnippetsUnavailable">;
+} & {
+    snapshotId: typeof Schema.String;
+    query: typeof Schema.String;
+}>;
+export declare class SnapshotSnippetsUnavailable extends SnapshotSnippetsUnavailable_base {
+    get message(): string;
+}
+interface SearchCommandConfig {
+    readonly snapshotId: string;
+    readonly query: string;
+    readonly format: 'text' | 'json';
+    readonly maxResults: number;
+    readonly minScore: number;
+}
+export declare const SearchCommand: Command.Command<'search', never, unknown, SearchCommandConfig>;
+export {};
+//# sourceMappingURL=Search.d.ts.map

package/build/dts/Commands/Search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Search.d.ts","sourceRoot":"","sources":["../../../src/Commands/Search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAW,MAAM,aAAa,CAAA;AACpD,OAAO,EAAiC,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;;;AAK9D,qBAAa,2BAA4B,SAAQ,gCAMhD;IACA,IAAI,OAAO,WAEV;CACD;AAkCD,UAAU,mBAAmB;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CACzB;AAED,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAiCxF,CAAA"}

package/build/dts/Commands/Skill.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@effect/cli';
+import { Skill } from '../Install/Skill.js';
+export declare const SkillCommand: Command.Command<"skill", Skill, import("@effect/platform/Error").PlatformError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly host: "claude-code" | "cursor" | "opencode" | "codex";
+        readonly scope: "project" | "global";
+    } | {
+        readonly host: "claude-code" | "cursor" | "opencode" | "codex";
+        readonly scope: "project" | "global";
+    }>;
+}>;
+//# sourceMappingURL=Skill.d.ts.map

package/build/dts/Commands/Skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../src/Commands/Skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAwB3C,eAAO,MAAM,YAAY;;;;;;;;EAGxB,CAAA"}

package/build/dts/Commands/Uninstall.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Uninstall } from '../Install/Uninstall.js';
+export declare const UninstallCommand: Command.Command<"uninstall", Uninstall, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError | import("../Install/Domain.js").McpParseError | import("../Install/Domain.js").McpWriteError, {
+    readonly target: Option.Option<"mcp" | "all" | "hook" | "skill">;
+    readonly host: Option.Option<"claude-code" | "cursor" | "opencode" | "codex">;
+    readonly scope: Option.Option<"project" | "global">;
+}>;
+//# sourceMappingURL=Uninstall.d.ts.map

package/build/dts/Commands/Uninstall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uninstall.d.ts","sourceRoot":"","sources":["../../../src/Commands/Uninstall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAqBnD,eAAO,MAAM,gBAAgB;;;;EAc5B,CAAA"}

package/build/dts/Config.d.ts

@@ -0,0 +1,105 @@
+import { FileSystem, Path } from '@effect/platform';
+import { DateTime, Effect, Schema } from 'effect';
+/** Production API endpoint used when neither `EXPAND_API_URL` nor the config file overrides it. */
+export declare const DEFAULT_API_URL = "https://api.expand.ai";
+export declare const ApiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
+export declare const ApiKeyConfig: Schema.TaggedStruct<"ApiKey", {
+    apiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
+}>;
+export declare const OAuthConfig: Schema.TaggedStruct<"OAuth", {
+    accessToken: Schema.Redacted<typeof Schema.String>;
+    refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
+    expiresAt: typeof Schema.DateTimeUtc;
+}>;
+declare const ExpandCliConfig_base: Schema.Class<ExpandCliConfig, {
+    apiUrl: Schema.optional<typeof Schema.URL>;
+    authMethod: Schema.optional<Schema.Union<[Schema.TaggedStruct<"ApiKey", {
+        apiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
+    }>, Schema.TaggedStruct<"OAuth", {
+        accessToken: Schema.Redacted<typeof Schema.String>;
+        refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
+        expiresAt: typeof Schema.DateTimeUtc;
+    }>]>>;
+}, Schema.Struct.Encoded<{
+    apiUrl: Schema.optional<typeof Schema.URL>;
+    authMethod: Schema.optional<Schema.Union<[Schema.TaggedStruct<"ApiKey", {
+        apiKey: Schema.Redacted<Schema.brand<typeof Schema.NonEmptyTrimmedString, "ApiKey">>;
+    }>, Schema.TaggedStruct<"OAuth", {
+        accessToken: Schema.Redacted<typeof Schema.String>;
+        refreshToken: Schema.optional<Schema.Redacted<typeof Schema.String>>;
+        expiresAt: typeof Schema.DateTimeUtc;
+    }>]>>;
+}>, never, {
+    readonly apiUrl?: URL | undefined;
+} & {
+    readonly authMethod?: {
+        readonly apiKey: import("effect/Redacted").Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
+        readonly _tag: "ApiKey";
+    } | {
+        readonly accessToken: import("effect/Redacted").Redacted<string>;
+        readonly refreshToken?: import("effect/Redacted").Redacted<string> | undefined;
+        readonly expiresAt: DateTime.Utc;
+        readonly _tag: "OAuth";
+    } | undefined;
+}, {}, {}>;
+export declare class ExpandCliConfig extends ExpandCliConfig_base {
+    static readonly Json: Schema.transform<Schema.SchemaClass<unknown, string, never>, typeof ExpandCliConfig>;
+}
+declare const ConfigNotWritable_base: Schema.TaggedErrorClass<ConfigNotWritable, "ConfigNotWritable", {
+    readonly _tag: Schema.tag<"ConfigNotWritable">;
+} & {
+    path: typeof Schema.String;
+}>;
+export declare class ConfigNotWritable extends ConfigNotWritable_base {
+    get message(): string;
+}
+declare const ConfigParseError_base: Schema.TaggedErrorClass<ConfigParseError, "ConfigParseError", {
+    readonly _tag: Schema.tag<"ConfigParseError">;
+} & {
+    path: typeof Schema.String;
+    error: typeof Schema.Defect;
+}>;
+export declare class ConfigParseError extends ConfigParseError_base {
+    get message(): string;
+}
+declare const NotAuthenticated_base: Schema.TaggedErrorClass<NotAuthenticated, "NotAuthenticated", {
+    readonly _tag: Schema.tag<"NotAuthenticated">;
+}>;
+export declare class NotAuthenticated extends NotAuthenticated_base {
+    get message(): string;
+}
+declare const OAuthTokenExpired_base: Schema.TaggedErrorClass<OAuthTokenExpired, "OAuthTokenExpired", {
+    readonly _tag: Schema.tag<"OAuthTokenExpired">;
+} & {
+    expiredAt: typeof Schema.DateTimeUtc;
+}>;
+export declare class OAuthTokenExpired extends OAuthTokenExpired_base {
+    get message(): string;
+}
+declare const ConfigManager_base: Effect.Service.Class<ConfigManager, "@expandai/cli/Config/ConfigManager", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<FileSystem.FileSystem, never, never>, import("effect/Layer").Layer<Path.Path, never, never>];
+    readonly effect: Effect.Effect<{
+        readonly configPath: string;
+        readonly loadConfig: () => Effect.Effect<{
+            apiUrl: URL;
+            authMethod: NonNullable<{
+                readonly apiKey: import("effect/Redacted").Redacted<string & import("effect/Brand").Brand<"ApiKey">>;
+                readonly _tag: "ApiKey";
+            } | {
+                readonly accessToken: import("effect/Redacted").Redacted<string>;
+                readonly refreshToken?: import("effect/Redacted").Redacted<string> | undefined;
+                readonly expiresAt: DateTime.Utc;
+                readonly _tag: "OAuth";
+            } | undefined>;
+        }, ConfigParseError | NotAuthenticated | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, never>;
+        readonly saveConfig: (config: ExpandCliConfig) => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
+        readonly updateConfig: (patch: Partial<ExpandCliConfig>) => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
+        readonly clearConfig: () => Effect.Effect<void, ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
+        readonly getApiUrl: () => Effect.Effect<URL, ConfigParseError | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, never>;
+        readonly getPlaygroundHost: () => Effect.Effect<string, import("effect/ConfigError").ConfigError, never>;
+    }, import("effect/ConfigError").ConfigError, FileSystem.FileSystem | Path.Path>;
+}>;
+export declare class ConfigManager extends ConfigManager_base {
+}
+export {};
+//# sourceMappingURL=Config.d.ts.map

package/build/dts/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/Config.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAGnD,OAAO,EAAU,QAAQ,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEjE,mGAAmG;AACnG,eAAO,MAAM,eAAe,0BAA0B,CAAA;AAEtD,eAAO,MAAM,MAAM,8EAA6E,CAAA;AAEhG,eAAO,MAAM,YAAY;;EAAoD,CAAA;AAC7E,eAAO,MAAM,WAAW;;;;EAItB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,eAAgB,SAAQ,oBAGnC;IACD,MAAM,CAAC,QAAQ,CAAC,IAAI,uFAAoC;CACxD;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAGpC;IACD,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,gBAAiB,SAAQ,qBAA8D;IACnG,IAAI,OAAO,WAEV;CACD;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAErC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;;;;;;;;;;;;;;;;;;AAYD,qBAAa,aAAc,SAAQ,kBA2HjC;CAAG"}

package/build/dts/DeviceAuth.d.ts

@@ -0,0 +1,87 @@
+import { HttpClient } from '@effect/platform';
+import { Duration, Effect, Schema } from 'effect';
+import { ConfigManager } from './Config.js';
+declare const DeviceCodeResponse_base: Schema.Class<DeviceCodeResponse, {
+    device_code: typeof Schema.String;
+    user_code: Schema.transform<typeof Schema.String, typeof Schema.String>;
+    verification_uri: typeof Schema.String;
+    verification_uri_complete: typeof Schema.String;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    interval: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+}, Schema.Struct.Encoded<{
+    device_code: typeof Schema.String;
+    user_code: Schema.transform<typeof Schema.String, typeof Schema.String>;
+    verification_uri: typeof Schema.String;
+    verification_uri_complete: typeof Schema.String;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    interval: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+}>, never, {
+    readonly expires_in: Duration.Duration;
+} & {
+    readonly device_code: string;
+} & {
+    readonly user_code: string;
+} & {
+    readonly verification_uri: string;
+} & {
+    readonly verification_uri_complete: string;
+} & {
+    readonly interval: Duration.Duration;
+}, {}, {}>;
+export declare class DeviceCodeResponse extends DeviceCodeResponse_base {
+}
+declare const TokenResponse_base: Schema.Class<TokenResponse, {
+    access_token: typeof Schema.String;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    token_type: typeof Schema.String;
+    scope: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    access_token: typeof Schema.String;
+    expires_in: Schema.transform<typeof Schema.Number, typeof Schema.DurationFromSelf>;
+    token_type: typeof Schema.String;
+    scope: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly access_token: string;
+} & {
+    readonly expires_in: Duration.Duration;
+} & {
+    readonly token_type: string;
+} & {
+    readonly scope?: string | undefined;
+}, {}, {}>;
+export declare class TokenResponse extends TokenResponse_base {
+}
+declare const DeviceAuthRequestFailed_base: Schema.TaggedErrorClass<DeviceAuthRequestFailed, "DeviceAuthRequestFailed", {
+    readonly _tag: Schema.tag<"DeviceAuthRequestFailed">;
+} & {
+    endpoint: typeof Schema.String;
+    error: typeof Schema.Defect;
+    status: Schema.optional<typeof Schema.Number>;
+}>;
+export declare class DeviceAuthRequestFailed extends DeviceAuthRequestFailed_base {
+    get message(): string;
+}
+declare const DeviceAuthorizationDenied_base: Schema.TaggedErrorClass<DeviceAuthorizationDenied, "DeviceAuthorizationDenied", {
+    readonly _tag: Schema.tag<"DeviceAuthorizationDenied">;
+}>;
+export declare class DeviceAuthorizationDenied extends DeviceAuthorizationDenied_base {
+    get message(): string;
+}
+declare const DeviceAuthorizationExpired_base: Schema.TaggedErrorClass<DeviceAuthorizationExpired, "DeviceAuthorizationExpired", {
+    readonly _tag: Schema.tag<"DeviceAuthorizationExpired">;
+}>;
+export declare class DeviceAuthorizationExpired extends DeviceAuthorizationExpired_base {
+    get message(): string;
+}
+declare const DeviceAuthService_base: Effect.Service.Class<DeviceAuthService, "@expandai/cli/DeviceAuthService", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<HttpClient.HttpClient, never, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly requestDeviceCode: () => Effect.Effect<DeviceCodeResponse, import("@effect/platform/HttpBody").HttpBodyError | DeviceAuthRequestFailed, never>;
+        readonly pollForToken: (deviceCode: string, interval: Duration.Duration, expiresIn: Duration.Duration) => Effect.Effect<TokenResponse, DeviceAuthRequestFailed | DeviceAuthorizationDenied | DeviceAuthorizationExpired, never>;
+        readonly saveToken: (tokenResponse: TokenResponse) => Effect.Effect<void, import("./Config.js").ConfigNotWritable | import("effect/ParseResult").ParseError, never>;
+    }, import("./Config.js").ConfigParseError | import("effect/ConfigError").ConfigError | import("@effect/platform/Error").PlatformError, ConfigManager | HttpClient.HttpClient>;
+}>;
+export declare class DeviceAuthService extends DeviceAuthService_base {
+}
+export {};
+//# sourceMappingURL=DeviceAuth.d.ts.map

package/build/dts/DeviceAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceAuth.d.ts","sourceRoot":"","sources":["../../src/DeviceAuth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyC,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAY,QAAQ,EAAE,MAAM,EAA6C,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC9G,OAAO,EAAE,aAAa,EAAe,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBxD,qBAAa,kBAAmB,SAAQ,uBAOtC;CAAG;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAKjC;CAAG;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAI3C;IACD,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,yBAA0B,SAAQ,8BAG9C;IACA,IAAI,OAAO,WAEV;CACD;;;;AAED,qBAAa,0BAA2B,SAAQ,+BAG/C;IACA,IAAI,OAAO,WAEV;CACD;;;;;;;;;AAID,qBAAa,iBAAkB,SAAQ,sBA8HrC;CAAG"}

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

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { ApiClient } from '../ApiClient.js';
+import { HookProtocolFailed } from './Errors.js';
+declare const ClaudeHook_base: Effect.Service.Class<ClaudeHook, "@expandai/cli/Hook/Claude", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<ApiClient, import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly runProtocol: () => Effect.Effect<void, HookProtocolFailed, never>;
+    }, never, ApiClient>;
+}>;
+export declare class ClaudeHook extends ClaudeHook_base {
+}
+export {};
+//# sourceMappingURL=Claude.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Claude.d.ts","sourceRoot":"","sources":["../../../src/Hook/Claude.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,MAAM,EAAkB,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,kBAAkB,EAAkB,MAAM,aAAa,CAAA;;;;;;;AAqChE,qBAAa,UAAW,SAAQ,eAuC9B;CAAG"}

package/build/dts/Hook/Errors.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'effect';
+declare const StdinReadError_base: Schema.TaggedErrorClass<StdinReadError, "StdinReadError", {
+    readonly _tag: Schema.tag<"StdinReadError">;
+} & {
+    error: typeof Schema.Defect;
+}>;
+export declare class StdinReadError extends StdinReadError_base {
+    get message(): string;
+}
+declare const HookProtocolFailed_base: Schema.TaggedErrorClass<HookProtocolFailed, "HookProtocolFailed", {
+    readonly _tag: Schema.tag<"HookProtocolFailed">;
+} & {
+    error: typeof Schema.Defect;
+    url: Schema.optional<typeof Schema.String>;
+}>;
+export declare class HookProtocolFailed extends HookProtocolFailed_base {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=Errors.d.ts.map

package/build/dts/Hook/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../../src/Hook/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;;AAE/B,qBAAa,cAAe,SAAQ,mBAElC;IACD,IAAI,OAAO,WAEV;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;IACD,IAAI,OAAO,WAGV;CACD"}

package/build/dts/Hook/Opencode.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { ApiClient } from '../ApiClient.js';
+import { HookProtocolFailed } from './Errors.js';
+declare const OpencodeHook_base: Effect.Service.Class<OpencodeHook, "@expandai/cli/Hook/Opencode", {
+    readonly dependencies: readonly [import("effect/Layer").Layer<ApiClient, import("effect/ConfigError").ConfigError, never>];
+    readonly effect: Effect.Effect<{
+        readonly runProtocol: () => Effect.Effect<void, HookProtocolFailed, never>;
+    }, never, ApiClient>;
+}>;
+export declare class OpencodeHook extends OpencodeHook_base {
+}
+export {};
+//# sourceMappingURL=Opencode.d.ts.map

package/build/dts/Hook/Opencode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Opencode.d.ts","sourceRoot":"","sources":["../../../src/Hook/Opencode.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,MAAM,EAAkB,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,kBAAkB,EAAkB,MAAM,aAAa,CAAA;;;;;;;AAqBhE,qBAAa,YAAa,SAAQ,iBAgChC;CAAG"}

package/build/dts/Hook/SnapshotNote.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 declare function withSnapshotNote(markdown: string, snapshotId: string, playgroundUrl: string): string;
+//# sourceMappingURL=SnapshotNote.d.ts.map

package/build/dts/Hook/SnapshotNote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapshotNote.d.ts","sourceRoot":"","sources":["../../../src/Hook/SnapshotNote.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASpG"}

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

@@ -0,0 +1,60 @@
+import { Effect, Schema } from 'effect';
+import { ConfigIo } from '../Domain.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 declare const HOOK_COMMAND = "expandai hook claude-code";
+export declare const WEBFETCH_MATCHER = "WebFetch";
+export declare const HookCommandEntry: Schema.Struct<{
+    type: Schema.Literal<["command"]>;
+    command: typeof Schema.String;
+}>;
+export declare const HookMatcher: Schema.Struct<{
+    matcher: Schema.optional<typeof Schema.String>;
+    hooks: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["command"]>;
+        command: typeof Schema.String;
+    }>>;
+}>;
+declare const HooksSection: Schema.TypeLiteral<{
+    PreToolUse: Schema.optional<Schema.Array$<Schema.Struct<{
+        matcher: Schema.optional<typeof Schema.String>;
+        hooks: Schema.Array$<Schema.Struct<{
+            type: Schema.Literal<["command"]>;
+            command: typeof Schema.String;
+        }>>;
+    }>>>;
+}, 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.Struct<{
+            matcher: Schema.optional<typeof Schema.String>;
+            hooks: Schema.Array$<Schema.Struct<{
+                type: Schema.Literal<["command"]>;
+                command: typeof Schema.String;
+            }>>;
+        }>>>;
+    }, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>, {
+        default: () => typeof HooksSection.Type;
+    }>;
+}, readonly [Schema.Record$<typeof Schema.String, typeof Schema.Unknown>]>>;
+export declare const expandaiMatcher: {
+    matcher: string;
+    hooks: {
+        type: "command";
+        command: string;
+    }[];
+};
+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: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, import("effect/ParseResult").ParseError | import("@effect/platform/Error").PlatformError, never>;
+    }, import("effect/ConfigError").ConfigError, ConfigIo>;
+}>;
+export declare class ClaudeHook extends ClaudeHook_base {
+}
+export {};
+//# sourceMappingURL=Hook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Hook.d.ts","sourceRoot":"","sources":["../../../../src/Install/Claude/Hook.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,MAAM,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGvC;;;;GAIG;AAEH,eAAO,MAAM,YAAY,8BAA8B,CAAA;AACvD,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,eAAO,MAAM,gBAAgB;;;EAG3B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;EAGtB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;0EAGjB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;uBAE2C,OAAO,YAAY,CAAC,IAAI;;2EAI7F,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;CAG3B,CAAA;;;;;;;;AAED,qBAAa,UAAW,SAAQ,eA0F9B;CAAG"}

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

@@ -0,0 +1,45 @@
+import { Effect, Schema } from 'effect';
+import { 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 type: "stdio";
+} & {
+    readonly command: string;
+} & {
+    readonly args: readonly string[];
+} & {
+    readonly env?: {
+        readonly [x: string]: string;
+    } | undefined;
+}, {}, {}>;
+/**
+ * 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 declare class Entry extends Entry_base {
+}
+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: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, McpParseError | McpWriteError, never>;
+        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, McpParseError, never>;
+        readonly pathFor: (scope: "project" | "global") => 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

@@ -0,0 +1 @@
+{"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,EAAE,QAAQ,EAAE,aAAa,EAA0B,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;AAGzG;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cA8D7B;CAAG"}

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

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

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

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

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

@@ -0,0 +1,39 @@
+import { Effect, Schema } from 'effect';
+import { ConfigIo, McpParseError, McpWriteError } from '../Domain.js';
+declare const Entry_base: Schema.Class<Entry, {
+    command: typeof Schema.NonEmptyTrimmedString;
+    args: Schema.Array$<typeof Schema.String>;
+    enabled: typeof Schema.Boolean;
+}, Schema.Struct.Encoded<{
+    command: typeof Schema.NonEmptyTrimmedString;
+    args: Schema.Array$<typeof Schema.String>;
+    enabled: typeof Schema.Boolean;
+}>, never, {
+    readonly command: string;
+} & {
+    readonly args: readonly 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>];
+    readonly effect: Effect.Effect<{
+        readonly install: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | McpParseError | McpWriteError, never>;
+        readonly uninstall: (scope: "project" | "global") => Effect.Effect<void, import("@effect/platform/Error").PlatformError | McpParseError | McpWriteError, never>;
+        readonly isInstalled: (scope: "project" | "global") => Effect.Effect<boolean, import("@effect/platform/Error").PlatformError | McpParseError, never>;
+        readonly pathFor: (scope: "project" | "global") => Effect.Effect<string, never, never>;
+    }, import("effect/ConfigError").ConfigError, 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

@@ -0,0 +1 @@
+{"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,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAc,MAAM,cAAc,CAAA;;;;;;;;;;;;;;;;AAGjF,qBAAa,KAAM,SAAQ,UAIzB;CAAG;;;;;;;;;;AAgBL;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aA2E5B;CAAG"}

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

@@ -0,0 +1,20 @@
+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: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, never>;
+        readonly uninstall: (scope: "project" | "global") => Effect.Effect<string, import("@effect/platform/Error").PlatformError, 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

@@ -0,0 +1 @@
+{"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,eAyB9B;CAAG"}