expandai 0.0.4 → 0.0.6

package/build/dts/Mcp/tools/Citations.d.ts

@@ -1,266 +0,0 @@
-import type { FetchObjectModeResultWithJson, FetchSnapshotSearchResultWithJson } from '@expandai/sdk/FetchJson';
-import * as Generated from '@expandai/sdk/Generated';
-import { Schema as S } from 'effect';
-export declare const FetchInvocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
-export type FetchInvocationPath = typeof FetchInvocationPath.Type;
-declare const CitedSnippet_base: S.Class<CitedSnippet, {
-    type: S.optionalWith<S.Literal<["text"]>, {
-        nullable: true;
-        default: () => "text";
-    }>;
-    source: S.Literal<["markdown", "appendix", "statejson"]>;
-    text: typeof S.String;
-    json: S.optionalWith<typeof S.Unknown, {
-        nullable: true;
-    }>;
-    score: S.filter<S.filter<typeof S.Number>>;
-    location: S.optionalWith<typeof Generated.FetchSearchSnippetLocation, {
-        nullable: true;
-    }>;
-    citationUrl: S.SchemaClass<string, string, never>;
-}, S.Struct.Encoded<{
-    type: S.optionalWith<S.Literal<["text"]>, {
-        nullable: true;
-        default: () => "text";
-    }>;
-    source: S.Literal<["markdown", "appendix", "statejson"]>;
-    text: typeof S.String;
-    json: S.optionalWith<typeof S.Unknown, {
-        nullable: true;
-    }>;
-    score: S.filter<S.filter<typeof S.Number>>;
-    location: S.optionalWith<typeof Generated.FetchSearchSnippetLocation, {
-        nullable: true;
-    }>;
-    citationUrl: S.SchemaClass<string, string, never>;
-}>, never, {
-    readonly json?: unknown;
-} & {
-    readonly location?: {
-        readonly evidenceId?: number | undefined;
-        readonly markdownBlockId?: string | undefined;
-        readonly nodeIds?: readonly number[] | undefined;
-        readonly stateJsonSourceId?: number | undefined;
-        readonly jsonPath?: string | undefined;
-    } | undefined;
-} & {
-    readonly type?: "text" | undefined;
-} & {
-    readonly citationUrl: string;
-} & {
-    readonly score: number;
-} & {
-    readonly source: "appendix" | "markdown" | "statejson";
-} & {
-    readonly text: string;
-}, {}, {}>;
-export declare class CitedSnippet extends CitedSnippet_base {
-}
-/**
- * Carried in the tool result itself, not only in `SKILL.md`. A harness may not load
- * skills at all, and the hook's snapshot note never reaches this path — so without
- * this the model receives perfect `citationUrl`s and no instruction to use them, and
- * answers with no citation. Observed on OpenCode before this was added.
- */
-export declare const CITATION_INSTRUCTIONS: string;
-declare const CitedSearchResult_base: S.Class<CitedSearchResult, {
-    query: typeof S.String;
-    snippets: S.Array$<typeof CitedSnippet>;
-    meta: S.optionalWith<typeof Generated.FetchSearchMeta, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    query: typeof S.String;
-    snippets: S.Array$<typeof CitedSnippet>;
-    meta: S.optionalWith<typeof Generated.FetchSearchMeta, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly meta?: {
-        readonly durationMs: number;
-        readonly sources: readonly {
-            readonly source: "appendix" | "markdown" | "statejson";
-            readonly chunkCount: number;
-            readonly batchCount: number;
-            readonly ranker: "local_lexical" | "zeroentropy";
-            readonly fallback: boolean;
-            readonly fallbackReason?: "error" | "timeout" | undefined;
-            readonly durationMs: number;
-        }[];
-    } | undefined;
-} & {
-    readonly query: string;
-} & {
-    readonly snippets: readonly CitedSnippet[];
-}, {}, {}>;
-export declare class CitedSearchResult extends CitedSearchResult_base {
-}
-declare const CitedObjectModeResult_base: S.Class<CitedObjectModeResult, {
-    invocationPath: S.Literal<["mcp-fetch-search"]>;
-    citationInstructions: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    citationBlock: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    meta: typeof Generated.FetchObjectModeMeta;
-    markdown: typeof S.String;
-    json: S.Array$<typeof Generated.FetchObjectModeEvidence>;
-    data: S.optionalWith<S.Struct<{
-        assets: S.optionalWith<S.Array$<typeof Generated.FetchAssetReference>, {
-            nullable: true;
-        }>;
-        search: S.optionalWith<typeof CitedSearchResult, {
-            nullable: true;
-        }>;
-    }>, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    invocationPath: S.Literal<["mcp-fetch-search"]>;
-    citationInstructions: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    citationBlock: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    meta: typeof Generated.FetchObjectModeMeta;
-    markdown: typeof S.String;
-    json: S.Array$<typeof Generated.FetchObjectModeEvidence>;
-    data: S.optionalWith<S.Struct<{
-        assets: S.optionalWith<S.Array$<typeof Generated.FetchAssetReference>, {
-            nullable: true;
-        }>;
-        search: S.optionalWith<typeof CitedSearchResult, {
-            nullable: true;
-        }>;
-    }>, {
-        nullable: true;
-    }>;
-}>, never, {
-    readonly data?: {
-        readonly assets?: readonly {
-            readonly id: string;
-            readonly kind: "data-url";
-            readonly placeholder: string;
-            readonly archiveKey: string;
-            readonly mimeType: string;
-            readonly sha256: string;
-            readonly bytes: number;
-        }[] | undefined;
-        readonly search?: CitedSearchResult | undefined;
-    } | undefined;
-} & {
-    readonly citationBlock?: string | undefined;
-} & {
-    readonly citationInstructions?: string | undefined;
-} & {
-    readonly invocationPath: "mcp-fetch-search";
-} & {
-    readonly json: readonly {
-        readonly id: number;
-        readonly kind: "inline" | "network";
-        readonly role: "apollo-state" | "application-json" | "data-attribute" | "initial-state" | "ld+json" | "network-json" | "network-response" | "next-data" | "nuxt" | "other" | "script-tag";
-        readonly score: number;
-        readonly url?: string | undefined;
-        readonly method?: string | undefined;
-        readonly moreTokens?: number | undefined;
-        readonly keys?: readonly string[] | undefined;
-    }[];
-} & {
-    readonly markdown: string;
-} & {
-    readonly meta: {
-        readonly version: 1;
-        readonly url: string;
-        readonly capturedAt: string;
-        readonly snapshotId: string;
-        readonly lang: string;
-        readonly pageType: string;
-        readonly playground: string;
-        readonly title?: string | undefined;
-        readonly finalUrl?: string | undefined;
-        readonly canonical?: string | undefined;
-        readonly description?: string | undefined;
-        readonly author?: string | undefined;
-        readonly createdAt?: string | undefined;
-        readonly updatedAt?: string | undefined;
-        readonly image?: string | undefined;
-        readonly paginationNext?: string | undefined;
-        readonly appendix?: {
-            readonly url: string;
-            readonly links: {
-                readonly sameDomain: number;
-                readonly external: number;
-            };
-        } | undefined;
-        readonly stateJson?: {
-            readonly moreTokens: number;
-        } | undefined;
-        readonly markdown?: {
-            readonly url: string;
-            readonly moreTokens: number;
-        } | undefined;
-        readonly blocked?: string | undefined;
-        readonly loadingStatus?: string | undefined;
-    };
-}, {}, {}>;
-export declare class CitedObjectModeResult extends CitedObjectModeResult_base {
-}
-declare const CitedSnapshotSearchResult_base: S.Class<CitedSnapshotSearchResult, {
-    invocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
-    citationInstructions: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    citationBlock: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    snapshotId: S.filter<typeof S.String>;
-    response: typeof Generated.ResponseInfo;
-    search: typeof CitedSearchResult;
-    durationMs: S.filter<typeof S.Number>;
-    playground: S.SchemaClass<string, string, never>;
-}, S.Struct.Encoded<{
-    invocationPath: S.Literal<["cli-recovery", "mcp-fetch-search"]>;
-    citationInstructions: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    citationBlock: S.optionalWith<typeof S.String, {
-        default: () => string;
-    }>;
-    snapshotId: S.filter<typeof S.String>;
-    response: typeof Generated.ResponseInfo;
-    search: typeof CitedSearchResult;
-    durationMs: S.filter<typeof S.Number>;
-    playground: S.SchemaClass<string, string, never>;
-}>, never, {
-    readonly citationBlock?: string | undefined;
-} & {
-    readonly citationInstructions?: string | undefined;
-} & {
-    readonly durationMs: number;
-} & {
-    readonly invocationPath: "cli-recovery" | "mcp-fetch-search";
-} & {
-    readonly playground: string;
-} & {
-    readonly response: {
-        readonly url: string;
-        readonly requestedUrl?: string | undefined;
-        readonly originStatusCode?: number | undefined;
-        readonly redirectStatusCode?: number | undefined;
-        readonly headers?: {} | undefined;
-    };
-} & {
-    readonly search: CitedSearchResult;
-} & {
-    readonly snapshotId: string;
-}, {}, {}>;
-export declare class CitedSnapshotSearchResult extends CitedSnapshotSearchResult_base {
-}
-/** Add `citationUrl` to each snippet of an object-mode fetch result. */
-export declare function enrichObjectModeResult(result: FetchObjectModeResultWithJson, fallbackHost: string): CitedObjectModeResult;
-/** Add `citationUrl` to each snippet of a snapshot-search result. */
-export declare function enrichSnapshotSearchResult(result: FetchSnapshotSearchResultWithJson, fallbackHost: string, invocationPath?: FetchInvocationPath): CitedSnapshotSearchResult;
-export {};
-//# sourceMappingURL=Citations.d.ts.map

package/build/dts/Mcp/tools/Citations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Citations.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Citations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,6BAA6B,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAA;AAC/G,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAA;AAEpD,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAEpC,eAAO,MAAM,mBAAmB,iDAAgD,CAAA;AAChF,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjE,qBAAa,YAAa,SAAQ,iBAUhC;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAO8D,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEhG,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,qBAAsB,SAAQ,0BAczC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAS7C;CAAG;AAyBL,wEAAwE;AACxE,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,6BAA6B,EACrC,YAAY,EAAE,MAAM,GAClB,qBAAqB,CA6BvB;AAED,qEAAqE;AACrE,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,iCAAiC,EACzC,YAAY,EAAE,MAAM,EACpB,cAAc,GAAE,mBAAwC,GACtD,yBAAyB,CAiB3B"}

package/build/dts/Mcp/tools/Fetch.d.ts

@@ -1,168 +0,0 @@
-import { Tool } from '@effect/ai';
-import { Effect, Schema } from 'effect';
-import { ApiClient } from '../../ApiClient.js';
-import { ConfigManager } from '../../Config.js';
-import { Telemetry } from '../../Telemetry.js';
-import { CitedObjectModeResult, CitedSnapshotSearchResult } from './Citations.js';
-declare const FetchSearchParams_base: Schema.Class<FetchSearchParams, {
-    query: Schema.refine<string, typeof Schema.Trimmed>;
-    maxResults: Schema.optionalWith<Schema.filter<typeof Schema.Int>, {
-        default: () => number;
-    }>;
-    minScore: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
-        default: () => number;
-    }>;
-}, Schema.Struct.Encoded<{
-    query: Schema.refine<string, typeof Schema.Trimmed>;
-    maxResults: Schema.optionalWith<Schema.filter<typeof Schema.Int>, {
-        default: () => number;
-    }>;
-    minScore: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
-        default: () => number;
-    }>;
-}>, never, {
-    readonly maxResults?: number | undefined;
-} & {
-    readonly minScore?: number | undefined;
-} & {
-    readonly query: string;
-}, {}, {}>;
-export declare class FetchSearchParams extends FetchSearchParams_base {
-}
-declare const FetchParams_base: Schema.Class<FetchParams, {
-    url: Schema.SchemaClass<string, string, never>;
-    search: Schema.optional<typeof FetchSearchParams>;
-    includeMeta: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}, Schema.Struct.Encoded<{
-    url: Schema.SchemaClass<string, string, never>;
-    search: Schema.optional<typeof FetchSearchParams>;
-    includeMeta: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}>, never, {
-    readonly search?: FetchSearchParams | undefined;
-} & {
-    readonly includeAppendix?: boolean | undefined;
-} & {
-    readonly includeJson?: boolean | undefined;
-} & {
-    readonly includeMeta?: boolean | undefined;
-} & {
-    readonly url: string;
-}, {}, {}>;
-export declare class FetchParams extends FetchParams_base {
-}
-declare const FetchSnapshotSearchParams_base: Schema.Class<FetchSnapshotSearchParams, {
-    snapshotId: Schema.refine<string, typeof Schema.String>;
-    search: Schema.SchemaClass<FetchSearchParams, {
-        readonly maxResults?: number | undefined;
-        readonly minScore?: number | undefined;
-        readonly query: string;
-    }, never>;
-    includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-    includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}, Schema.Struct.Encoded<{
-    snapshotId: Schema.refine<string, typeof Schema.String>;
-    search: Schema.SchemaClass<FetchSearchParams, {
-        readonly maxResults?: number | undefined;
-        readonly minScore?: number | undefined;
-        readonly query: string;
-    }, never>;
-    includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-    includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-    includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => true;
-    }>;
-}>, never, {
-    readonly includeAppendix?: boolean | undefined;
-} & {
-    readonly includeJson?: boolean | undefined;
-} & {
-    readonly includeMarkdown?: boolean | undefined;
-} & {
-    readonly search: FetchSearchParams;
-} & {
-    readonly snapshotId: string;
-}, {}, {}>;
-export declare class FetchSnapshotSearchParams extends FetchSnapshotSearchParams_base {
-}
-export declare const FetchTool: Tool.Tool<"fetch", {
-    readonly parameters: Schema.Struct<{
-        readonly url: Schema.SchemaClass<string, string, never>;
-        readonly search: Schema.optional<typeof FetchSearchParams>;
-        readonly includeMeta: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => false;
-        }>;
-        readonly includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => false;
-        }>;
-        readonly includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => true;
-        }>;
-    }>;
-    readonly success: typeof CitedObjectModeResult;
-    readonly failure: typeof Schema.Defect;
-    readonly failureMode: "return";
-}, never>;
-export declare const FetchSearchTool: Tool.Tool<"fetch_search", {
-    readonly parameters: Schema.Struct<{
-        readonly snapshotId: Schema.refine<string, typeof Schema.String>;
-        readonly search: Schema.SchemaClass<FetchSearchParams, {
-            readonly maxResults?: number | undefined;
-            readonly minScore?: number | undefined;
-            readonly query: string;
-        }, never>;
-        readonly includeMarkdown: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => true;
-        }>;
-        readonly includeAppendix: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => false;
-        }>;
-        readonly includeJson: Schema.optionalWith<typeof Schema.Boolean, {
-            default: () => true;
-        }>;
-    }>;
-    readonly success: typeof CitedSnapshotSearchResult;
-    readonly failure: typeof Schema.Defect;
-    readonly failureMode: "return";
-}, never>;
-export interface FetchService {
-    readonly fetch: (params: FetchParams) => Effect.Effect<CitedObjectModeResult, unknown>;
-    readonly fetchSearch: (params: FetchSnapshotSearchParams) => Effect.Effect<CitedSnapshotSearchResult, unknown>;
-}
-declare const Fetch_base: Effect.Service.Class<Fetch, "@expandai/cli/Mcp/Fetch", {
-    readonly dependencies: readonly [import("effect/Layer").Layer<ApiClient, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, import("effect/Layer").Layer<Telemetry, import("effect/ConfigError").ConfigError, never>];
-    readonly scoped: Effect.Effect<{
-        fetch: (params: FetchParams) => Effect.Effect<CitedObjectModeResult, unknown>;
-        fetchSearch: (params: FetchSnapshotSearchParams) => Effect.Effect<CitedSnapshotSearchResult, unknown>;
-    }, import("effect/ConfigError").ConfigError, ApiClient | ConfigManager | Telemetry>;
-}>;
-export declare class Fetch extends Fetch_base {
-}
-export {};
-//# sourceMappingURL=Fetch.d.ts.map

package/build/dts/Mcp/tools/Fetch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../../../src/Mcp/tools/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EACN,qBAAqB,EACrB,yBAAyB,EAGzB,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAEvB,qBAAa,iBAAkB,SAAQ,sBAYrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAmB/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,yBAA0B,SAAQ,8BAmB7C;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;SAmBa,CAAA;AAEnC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;SAmBO,CAAA;AAEnC,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAA;IACtF,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC,CAAA;CAC9G;;;;wBAFyB,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,OAAO,CAAC;8BACvD,yBAAyB,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,OAAO,CAAC;;;AAG/G,qBAAa,KAAM,SAAQ,UAuFzB;CAAG"}

package/build/dts/SecureFile.d.ts

@@ -1,23 +0,0 @@
-import { FileSystem, Error as PlatformError } from '@effect/platform';
-import { Effect, Exit } from 'effect';
-export interface CreatedFileIdentity {
-    readonly dev: number;
-    readonly ino?: number;
-    readonly mode: number;
-    readonly type: FileSystem.File.Type;
-}
-export interface ExclusiveFileCreation {
-    readonly identity: CreatedFileIdentity;
-    readonly writeExit: Exit.Exit<void, PlatformError.PlatformError>;
-    readonly pathMatchesHandle: boolean;
-}
-/** Creates a file exclusively and binds its identity to the opened handle before writing bytes. */
-export declare function createExclusiveFile(fileSystem: FileSystem.FileSystem, targetPath: string, contents: string, mode: number): Effect.Effect<ExclusiveFileCreation, PlatformError.PlatformError>;
-/** Compares a pathname snapshot with identity captured from the creating file handle. */
-export declare function matchesCreatedFile(identity: CreatedFileIdentity, pathIdentity: {
-    readonly exists: boolean;
-    readonly dev?: number;
-    readonly ino?: number;
-    readonly type?: FileSystem.File.Type;
-}): boolean;
-//# sourceMappingURL=SecureFile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SecureFile.d.ts","sourceRoot":"","sources":["../../src/SecureFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAU,MAAM,QAAQ,CAAA;AAE7C,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAA;CACnC;AAED,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IAChE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAA;CACnC;AAED,mGAAmG;AACnG,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,UAAU,CAAC,UAAU,EACjC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC,aAAa,CAAC,CA6BnE;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,mBAAmB,EAC7B,YAAY,EAAE;IACb,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAA;CACpC,GACC,OAAO,CAOT"}

package/build/dts/Snippets.d.ts

@@ -1,18 +0,0 @@
-import type { FetchObjectModeResultWithJson } from '@expandai/sdk/FetchJson';
-type SearchResultWithJson = NonNullable<NonNullable<FetchObjectModeResultWithJson['data']>['search']>;
-type RenderableSnippet = SearchResultWithJson['snippets'][number];
-/**
- * Attaches the public citation link to each snippet. JSON consumers get the same
- * auditable URL the text renderer prints in its header — without it, a caller has
- * the snapshot and the evidence id but no host to build a link against.
- */
-export declare function withCitationUrls<A extends RenderableSnippet>(snapshotId: string, host: string, snippets: ReadonlyArray<A>): Array<A & {
-    readonly citationUrl: string;
-}>;
-/**
- * Render search snippets as auditable text blocks: a header carrying the source, score, and
- * citation link, the snippet text, and — for State JSON snippets — the extracted JSON value.
- */
-export declare function renderSnippets(snapshotId: string, host: string, snippets: ReadonlyArray<RenderableSnippet>): string;
-export {};
-//# sourceMappingURL=Snippets.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Snippets.d.ts","sourceRoot":"","sources":["../../src/Snippets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAA;AAM5E,KAAK,oBAAoB,GAAG,WAAW,CAAC,WAAW,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;AACrG,KAAK,iBAAiB,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,EAC3D,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GACxB,KAAK,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAK7C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,MAAM,CASnH"}

package/build/dts/Telemetry.d.ts

@@ -1,30 +0,0 @@
-import { HttpClient } from '@effect/platform';
-import { Config, Effect, Layer, Option } from 'effect';
-import { ConfigManager } from './Config.js';
-export declare const TelemetryEnvironment: Config.Config<{
-    apiKey: string;
-    host: string;
-    doNotTrack: boolean;
-    noTelemetry: boolean;
-    apiUrl: Option.Option<string>;
-    harnessOverride: Option.Option<"claude-code" | "codex" | "cursor" | "opencode" | "unknown">;
-    claudeCode: boolean;
-    cursor: boolean;
-    codex: boolean;
-}>;
-declare const Telemetry_base: Effect.Service.Class<Telemetry, "@expandai/cli/Telemetry", {
-    readonly dependencies: readonly [Layer.Layer<ConfigManager, import("effect/ConfigError").ConfigError, never>, Layer.Layer<HttpClient.HttpClient, never, never>];
-    readonly scoped: Effect.Effect<{
-        readonly capture: (event: string, properties: Record<string, string | number | boolean>) => Effect.Effect<void, never, never>;
-        readonly flush: Effect.Effect<void, never, never>;
-        readonly showNoticeIfNeeded: () => Effect.Effect<void, never, never>;
-        readonly enabled: boolean;
-        readonly distinctId: string;
-    }, import("effect/ConfigError").ConfigError, ConfigManager | HttpClient.HttpClient | import("effect/Scope").Scope>;
-}>;
-export declare class Telemetry extends Telemetry_base {
-    /** A side-effect-free telemetry service for commands whose contract is read-only. */
-    static readonly DISABLED: Layer.Layer<Telemetry, never, never>;
-}
-export {};
-//# sourceMappingURL=Telemetry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Telemetry.d.ts","sourceRoot":"","sources":["../../src/Telemetry.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,UAAU,EAAqB,MAAM,kBAAkB,CAAA;AAEhE,OAAO,EAAE,MAAM,EAAW,MAAM,EAAY,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzE,OAAO,EAAE,aAAa,EAAwC,MAAM,aAAa,CAAA;AAOjF,eAAO,MAAM,oBAAoB;;;;;;;;;;EAc/B,CAAA;;;;;;;;;;;AA0BF,qBAAa,SAAU,SAAQ,cA2G7B;IACD,qFAAqF;IACrF,MAAM,CAAC,QAAQ,CAAC,QAAQ,uCASvB;CACD"}

package/build/dts/Version.d.ts

@@ -1,2 +0,0 @@
-export declare const CLI_VERSION = "0.0.4";
-//# sourceMappingURL=Version.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Version.d.ts","sourceRoot":"","sources":["../../src/Version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,UAAU,CAAA"}

package/build/dts/Xdg.d.ts

@@ -1,11 +0,0 @@
-import { Path } from '@effect/platform';
-import { Effect } from 'effect';
-/**
- * XDG base-directory lookup, shared by everything that persists CLI state so
- * the fallback rules cannot drift apart. The spec treats an unset and an empty
- * variable identically: fall back to `$HOME/.config`. Without the empty check,
- * `XDG_CONFIG_HOME=` resolves paths relative to the working directory — which
- * would drop credentials inside whatever project the CLI happens to run in.
- */
-export declare const xdgConfigDirectory: Effect.Effect<string, import("effect/ConfigError").ConfigError, Path.Path>;
-//# sourceMappingURL=Xdg.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Xdg.d.ts","sourceRoot":"","sources":["../../src/Xdg.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,4EAM7B,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/build/dts/main.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=main.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":""}