@http-forge/core 0.1.0 → 0.2.1

package/dist/execution/collection-request-executor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Collection Request Executor
+ *
+ * Executes a single collection request with full Postman parity:
+ * - Script execution order: Collection → Folder(s) → Request (pre-request)
+ * - Script execution order: Request → Folder(s) → Collection (post-response)
+ * - Supports nested folder scripts (multiple levels)
+ * - JavaScript variables declared in pre-request are accessible in post-response (shared VM session)
+ *
+ * Extracted from extension's request-execution/collection-request-executor.ts.
+ * Platform-independent — no vscode dependency.
+ */
+import { IEnvironmentConfigService } from '../environment/interfaces';
+import { IHttpRequestService } from '../http/interfaces';
+import { ICookieJar, IScriptExecutor } from '../script/interfaces';
+import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../types/types';
+import { ConsoleOutputCallback, ICollectionRequestExecutor } from './collection-request-executor-interfaces';
+import { IRequestPreparer } from './request-preparer-interfaces';
+/**
+ * Enhanced implementation with Postman parity.
+ * Supports: pre-request scripts, post-response scripts, cookies, settings,
+ * collection/folder scripts.
+ */
+export declare class CollectionRequestExecutor implements ICollectionRequestExecutor {
+    private readonly httpService;
+    private readonly scriptExecutor;
+    private readonly envConfigService;
+    private readonly requestPreparer;
+    private readonly environment;
+    private readonly cookieJar?;
+    private readonly collectionScripts?;
+    private readonly folderScriptsChain?;
+    private readonly onConsoleOutput?;
+    private readonly collectionName?;
+    private readonly iteration?;
+    private readonly iterationCount?;
+    constructor(httpService: IHttpRequestService, scriptExecutor: IScriptExecutor, envConfigService: IEnvironmentConfigService, requestPreparer: IRequestPreparer, environment: string, cookieJar?: ICookieJar | undefined, collectionScripts?: RequestScripts | undefined, folderScriptsChain?: (RequestScripts | RequestScripts[]) | undefined, onConsoleOutput?: ConsoleOutputCallback | undefined, collectionName?: string | undefined, iteration?: number | undefined, iterationCount?: number | undefined);
+    /**
+     * Execute a request with full Postman parity.
+     */
+    execute(request: ExecutionRequest, variables: Record<string, string>, signal?: AbortSignal): Promise<ExecutionResult>;
+    protected executeWithSession(request: ExecutionRequest, variables: Record<string, string>, signal: AbortSignal | undefined, startTime: number): Promise<ExecutionResult>;
+    /**
+     * Collect pre-request scripts in order: Collection → Folder(s) → Request
+     */
+    private collectPreRequestScripts;
+    /**
+     * Collect post-response scripts in order: Request → Folder(s) → Collection
+     */
+    private collectPostResponseScripts;
+    /**
+     * Handle execution errors — returns a failed ExecutionResult.
+     *
+     * The response body is set according to `errorBodyFormat`:
+     * - `'text'`  → plain-text error message (default, safe for CLI / headless)
+     * - `'html'`  → styled HTML suitable for a webview Response tab
+     * - `'both'`  → HTML body **and** `error` field with plain-text message
+     *
+     * Protected so subclasses can override error formatting entirely.
+     */
+    protected handleError(request: ExecutionRequest, prepared: PreparedRequest | null, error: any, startTime: number): ExecutionResult;
+    /**
+     * The format used for error response bodies.
+     *
+     * Override in a subclass (or set via constructor option) to switch formats:
+     * - `'text'`  — plain text (default)
+     * - `'html'`  — HTML for webview display
+     * - `'both'`  — HTML body + plain `error` field
+     */
+    protected get errorBodyFormat(): 'text' | 'html' | 'both';
+    /**
+     * Build a styled HTML string from an error message and optional stack trace.
+     * Useful for rendering errors in a webview Response tab.
+     *
+     * Static so callers can use it independently of an executor instance.
+     */
+    static formatErrorAsHtml(message: string, stack?: string): string;
+}

package/dist/{services → execution}/request-executor.d.ts

@@ -4,10 +4,11 @@
  * Single Responsibility: Orchestrate the complete request execution flow
  * Facade Pattern: Provides simplified interface to complex subsystem
  */
-import { IHttpClient, IRequestPreprocessor } from '../interfaces';
-import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../interfaces/types';
-import { IForgeEnv } from './forge-env';
-import { ScriptPipeline } from './script-pipeline';
+import { IForgeEnv } from '../environment/forge-env';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { IScriptExecutor } from '../script/interfaces';
+import { IHttpClient } from '../types/platform';
+import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../types/types';
 /**
  * Options for request execution
  */
@@ -24,6 +25,10 @@ export interface ExecuteOptions {
     additionalVariables?: Record<string, string>;
     /** Timeout override */
     timeout?: number;
+    /** Callback when scripts modify session variables */
+    onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
+    /** Callback when scripts modify environment variables */
+    onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }
 /**
  * Complete execution result
@@ -51,15 +56,17 @@ export interface ExecuteResult {
 export declare class RequestExecutor {
     private readonly httpClient;
     private readonly forgeEnv;
-    private readonly scriptPipeline;
+    private readonly cookieJar?;
     private readonly preprocessor?;
-    private moduleLoader?;
-    constructor(httpClient: IHttpClient, forgeEnv: IForgeEnv, scriptPipeline: ScriptPipeline, preprocessor?: IRequestPreprocessor | undefined, options?: {
+    private scriptExecutor;
+    constructor(httpClient: IHttpClient, forgeEnv: IForgeEnv, cookieJar?: any | undefined, // ICookieJar - optional for cookie support in scripts
+    preprocessor?: IRequestPreprocessor | undefined, options?: {
         forgeRoot?: string;
+        scriptExecutor?: IScriptExecutor;
     });
     /**
      * Execute a request with full pipeline
-     * Uses ScriptSession for shared VM context between pre-request and post-response scripts
+     * Uses RequestScriptSession for shared VM context between pre-request and post-response scripts
      */
     execute(request: UnifiedRequest, collection: UnifiedCollection, options?: ExecuteOptions): Promise<ExecuteResult>;
     /**
@@ -79,8 +86,13 @@ export declare class RequestExecutor {
      */
     private interpolateRequest;
     /**
-     * Create script context
+     * Build script chain for a request
+     * Returns scripts in execution order: collection → folders → request
      */
-    private createScriptContext;
+    private buildScriptChain;
+    /**
+     * Find the folder path from collection root to a request
+     * Returns array of folders in order from root to parent
+     */
+    private findFolderPath;
 }
-//# sourceMappingURL=request-executor.d.ts.map

package/dist/execution/request-preparer-interfaces.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Request Preparer Interface
+ *
+ * Defines the contract for preparing HTTP requests before execution.
+ * Handles variable resolution, header merging, auth injection, body encoding.
+ *
+ * Used by both Request Tester (manual) and Collection Runner (batch).
+ */
+import { ResolvedEnvironment } from '../environment/interfaces';
+import { ExecutionRequest, PreparedRequest } from '../types/types';
+/**
+ * Request Preparer Service Interface
+ *
+ * Extracted from extension's request-execution-handler.ts prepareRequest method.
+ * Shares request preparation logic between Request Tester and Collection Runner.
+ */
+export interface IRequestPreparer {
+    /**
+     * Prepare a request for execution.
+     *
+     * Handles:
+     * - Variable resolution in params, query, headers, body, URL
+     * - Header merging (environment + request headers)
+     * - Authentication (Bearer, Basic, API Key, OAuth2)
+     * - Body encoding based on bodyType
+     * - Content-Type header auto-setting
+     * - URL building with path params, query params
+     *
+     * @param input - Request input data (ExecutionRequest format)
+     * @param environment - Environment name for variable resolution
+     * @param resolvedEnv - Resolved environment configuration
+     * @param extraVariables - Optional extra variables (for data files, script variables)
+     * @returns Prepared request ready for HTTP execution
+     */
+    prepareRequest(input: ExecutionRequest, environment: string, resolvedEnv: ResolvedEnvironment, extraVariables?: Record<string, string>): Promise<PreparedRequest>;
+}

package/dist/execution/request-preparer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Request Preparer
+ *
+ * Prepares HTTP requests for execution by resolving variables,
+ * merging headers, applying authentication, and encoding body.
+ *
+ * Extracted from extension's request-preparer.ts.
+ * Platform-independent — uses IApplicationInfo instead of vscode.extensions.
+ *
+ * Used by both Request Tester (manual) and Collection Runner (batch).
+ */
+import { IOAuth2TokenManager } from '../auth/interfaces';
+import { IEnvironmentConfigService, ResolvedEnvironment } from '../environment/interfaces';
+import { IHttpRequestService } from '../http/interfaces';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { IApplicationInfo } from '../types/platform';
+import { ExecutionRequest, PreparedRequest } from '../types/types';
+import { IRequestPreparer } from './request-preparer-interfaces';
+/**
+ * RequestPreparer implementation
+ *
+ * Logic extracted from extension's request-execution-handler.ts prepareRequest method.
+ * Shared by Request Tester (manual requests) and Collection Runner (batch requests).
+ */
+export declare class RequestPreparer implements IRequestPreparer {
+    private readonly envConfigService;
+    private readonly httpService;
+    private readonly preprocessor;
+    private readonly tokenManager?;
+    private readonly appInfo?;
+    constructor(envConfigService: IEnvironmentConfigService, httpService: IHttpRequestService, preprocessor: IRequestPreprocessor, tokenManager?: IOAuth2TokenManager | undefined, appInfo?: IApplicationInfo | undefined);
+    prepareRequest(input: ExecutionRequest, environment: string, resolvedEnv: ResolvedEnvironment, extraVariables?: Record<string, string>): Promise<PreparedRequest>;
+    private applyOAuth2;
+    private applyApiKey;
+}

package/dist/graphql/graphql-completion-provider.d.ts

@@ -0,0 +1,39 @@
+/**
+ * GraphQL Completion Provider
+ *
+ * Single Responsibility: Parse GraphQL document context and produce completion items
+ * from a given schema. Pure logic — no VS Code or editor dependencies.
+ *
+ * This is a lightweight context parser using regex + brace counting — no graphql-js dependency.
+ *
+ * Completion Scenarios:
+ * - Root level: query, mutation, subscription, fragment keywords
+ * - Selection set: fields of the current parent type + __typename
+ * - Arguments: field argument names
+ * - Argument values: enum values for enum-typed arguments
+ * - Fragment spread: on TypeName, defined fragment names
+ * - Directives: @skip, @include, custom directives
+ * - Variable types: input types + scalars
+ */
+import { GraphQLSchema } from './graphql-schema-service';
+export type ContextType = 'root' | 'operation_name' | 'selection_set' | 'argument' | 'argument_value' | 'directive' | 'fragment_type' | 'variable_def';
+export interface QueryContext {
+    contextType: ContextType;
+    fieldPath: string[];
+    parentType?: string;
+    inFragment?: boolean;
+    prefix: string;
+    currentField?: string;
+    currentArg?: string;
+}
+export interface CompletionItem {
+    label: string;
+    kind: 'field' | 'keyword' | 'argument' | 'enum' | 'type' | 'directive' | 'fragment' | 'snippet';
+    detail?: string;
+    description?: string;
+    insertText?: string;
+    deprecated?: boolean;
+    sortOrder?: number;
+}
+export declare function parseQueryContext(document: string, offset: number, schema?: GraphQLSchema): QueryContext;
+export declare function getCompletions(schema: GraphQLSchema, context: QueryContext): CompletionItem[];

package/dist/graphql/graphql-schema-service.d.ts

@@ -0,0 +1,89 @@
+/**
+ * GraphQL Schema Service
+ *
+ * Single Responsibility: Fetch, parse, and cache GraphQL schemas via introspection.
+ *
+ * Features:
+ * - Execute standard introspection query against any GraphQL endpoint
+ * - Parse introspection result into typed schema representation
+ * - Cache schemas per-endpoint with timestamp
+ * - Extract operation names from GraphQL documents
+ * - Resolve variable types for operations
+ *
+ * Zero Dependencies: Uses only the project's IHttpClient abstraction.
+ */
+import { IHttpClient } from '../types/platform';
+export interface GraphQLField {
+    name: string;
+    type: string;
+    args: GraphQLArg[];
+    description?: string;
+    isDeprecated: boolean;
+    deprecationReason?: string;
+}
+export interface GraphQLArg {
+    name: string;
+    type: string;
+    defaultValue?: string;
+    description?: string;
+}
+export interface GraphQLEnumValue {
+    name: string;
+    description?: string;
+    isDeprecated: boolean;
+    deprecationReason?: string;
+}
+export interface GraphQLType {
+    name: string;
+    kind: 'OBJECT' | 'INPUT_OBJECT' | 'ENUM' | 'SCALAR' | 'INTERFACE' | 'UNION' | 'LIST' | 'NON_NULL';
+    fields: GraphQLField[];
+    inputFields: GraphQLArg[];
+    enumValues: GraphQLEnumValue[];
+    interfaces: string[];
+    possibleTypes: string[];
+    description?: string;
+}
+export interface GraphQLDirective {
+    name: string;
+    description?: string;
+    locations: string[];
+    args: GraphQLArg[];
+}
+export interface GraphQLSchema {
+    queryType: string;
+    mutationType?: string;
+    subscriptionType?: string;
+    types: Map<string, GraphQLType>;
+    directives: GraphQLDirective[];
+    fetchedAt: number;
+    endpointUrl: string;
+}
+export interface GraphQLOperation {
+    name: string;
+    type: 'query' | 'mutation' | 'subscription';
+    line: number;
+}
+export interface IGraphQLSchemaService {
+    fetchSchema(endpointUrl: string, headers?: Record<string, string>): Promise<GraphQLSchema>;
+    getCachedSchema(endpointUrl: string): GraphQLSchema | undefined;
+    extractOperations(document: string): GraphQLOperation[];
+    clearCache(endpointUrl?: string): void;
+    schemaToSerializable(schema: GraphQLSchema): any;
+}
+export declare class GraphQLSchemaService implements IGraphQLSchemaService {
+    private readonly httpClient;
+    private schemaCache;
+    constructor(httpClient: IHttpClient);
+    /**
+     * Execute introspection query and return parsed schema
+     */
+    fetchSchema(endpointUrl: string, headers?: Record<string, string>): Promise<GraphQLSchema>;
+    getCachedSchema(endpointUrl: string): GraphQLSchema | undefined;
+    extractOperations(document: string): GraphQLOperation[];
+    clearCache(endpointUrl?: string): void;
+    schemaToSerializable(schema: GraphQLSchema): any;
+    private parseSchema;
+    private parseField;
+    private parseArg;
+    private renderTypeRef;
+}

package/dist/{interfaces/history.d.ts → history/history-interfaces.d.ts}

@@ -4,7 +4,7 @@
  * Extracted from VS Code plugin: src/services/interfaces/request-history.interface.ts
  * Adapted for core package - storage-agnostic design
  */
-import { HttpRequest, HttpResponse } from './types';
+import { HttpRequest, HttpResponse, RequestBody } from '../types/types';
 /**
  * History entry - records a single request execution
  */
@@ -14,7 +14,7 @@ export interface HistoryEntry {
     /** Timestamp of execution */
     timestamp: number;
     /** Associated ticket/issue number */
-    ticket?: string;
+    ticket?: string | null;
     /** Git branch name */
     branch?: string;
     /** Environment used */
@@ -26,10 +26,34 @@ export interface HistoryEntry {
         url: string;
         method: string;
         headers: Record<string, string>;
-        body?: any;
+        body?: RequestBody | any | null;
         params?: Record<string, string>;
         query?: Record<string, string>;
     };
+    /** Original request configuration (before variable resolution) */
+    originalConfig?: {
+        path: string;
+        params: Record<string, string>;
+        query: Record<string, string>;
+        headers: Record<string, string>;
+        body: RequestBody | null;
+    };
+    /** Request settings */
+    settings?: {
+        timeout?: number;
+        followRedirects?: boolean;
+        followOriginalMethod?: boolean;
+        followAuthHeader?: boolean;
+        maxRedirects?: number;
+        strictSSL?: boolean;
+        decompress?: boolean;
+        includeCookies?: boolean;
+    };
+    /** Scripts associated with request */
+    scripts?: {
+        preRequest?: string;
+        postResponse?: string;
+    };
     /** Response summary */
     response: {
         status: number;
@@ -46,7 +70,7 @@ export interface FullResponse {
     timestamp: number;
     status: number;
     statusText: string;
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     cookies: any[];
     body: any;
     time: number;
@@ -59,7 +83,7 @@ export interface RequestHistory {
     requestPath: string;
     requestId: string;
     method: string;
-    entries: HistoryEntry[];
+    requests: HistoryEntry[];
 }
 /**
  * History read operations
@@ -114,4 +138,3 @@ export interface IRequestHistory extends IHistoryReader, IHistoryWriter {
     /** Maximum entries to keep per request (oldest removed when exceeded) */
     maxEntriesPerRequest: number;
 }
-//# sourceMappingURL=history.d.ts.map

package/dist/history/request-history-service-interfaces.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Request History Service Interface
+ *
+ * Interface Segregation: Separated into focused sub-interfaces
+ * Dependency Inversion: Consumers depend on this abstraction
+ */
+import { FullResponse, HistoryEntry, RequestHistory } from './history-interfaces';
+export type { FullResponse, HistoryEntry, RequestHistory };
+/**
+ * History read operations
+ */
+export interface IHistoryReader {
+    loadHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    loadSharedHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    getEntriesForEnvironment(environment: string, storagePath: string, endpointId: string): HistoryEntry[];
+    getEntriesGroupedByTicket(environment: string, storagePath: string, endpointId: string): Map<string, HistoryEntry[]>;
+    getSharedEntriesGroupedByTicket(environment: string, storagePath: string, endpointId: string): Map<string, HistoryEntry[]>;
+}
+/**
+ * History write operations
+ */
+export interface IHistoryWriter {
+    addEntry(environment: string, storagePath: string, endpointId: string, method: string, entry: Omit<HistoryEntry, 'id' | 'timestamp' | 'method'>): HistoryEntry;
+    deleteEntry(environment: string, storagePath: string, endpointId: string, entryId: string): boolean;
+    deleteSharedEntry(environment: string, storagePath: string, endpointId: string, entryId: string): boolean;
+    clearHistory(environment: string, storagePath: string, endpointId: string): void;
+    shareEntry(environment: string, storagePath: string, endpointId: string, entryId: string, tag: string): boolean;
+    moveSharedEntry(environment: string, storagePath: string, endpointId: string, entryId: string, tag: string): boolean;
+    renameSharedGroup(environment: string, storagePath: string, endpointId: string, oldTag: string, newTag: string): boolean;
+}
+/**
+ * Full response storage operations
+ */
+export interface IResponseStorage {
+    saveFullResponse(environment: string, requestPath: string, requestId: string, entryId: string, response: FullResponse): void;
+    loadFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+    loadSharedFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+}
+/**
+ * Full request history service interface
+ */
+export interface IRequestHistoryService extends IHistoryReader, IHistoryWriter, IResponseStorage {
+}

package/dist/history/request-history-service.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Request History Service - File-based Implementation
+ *
+ * Full-featured request history service with:
+ * - File-based persistence (JSON files on disk)
+ * - Shared history support (team-visible history)
+ * - Ticket/branch grouping
+ * - Separate full response file management
+ *
+ * Ported from VS Code extension's RequestHistoryService.
+ * No VS Code dependencies — uses only Node.js fs/path.
+ */
+import { FullResponse, HistoryEntry, RequestHistory } from './history-interfaces';
+import { IRequestHistoryService } from './request-history-service-interfaces';
+/**
+ * File-based request history service.
+ *
+ * Path-helper methods are `protected` so consumers can subclass and
+ * override the directory layout if needed.
+ */
+export declare class RequestHistoryService implements IRequestHistoryService {
+    protected historyPath: string;
+    protected sharedHistoryPath: string;
+    constructor(historyPath: string, sharedHistoryPath: string);
+    /**
+     * Get history folder path for environment
+     */
+    protected getEnvironmentHistoryPath(environment: string): string;
+    /**
+     * Get history folder path for a collection within an environment
+     */
+    protected getCollectionHistoryPath(environment: string, collectionPath: string): string;
+    /**
+     * Get request directory path
+     */
+    protected getRequestPath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get shared history folder path for environment
+     */
+    protected getSharedEnvironmentHistoryPath(environment: string): string;
+    /**
+     * Get shared history folder path for a collection within an environment
+     */
+    protected getSharedCollectionHistoryPath(environment: string, collectionPath: string): string;
+    /**
+     * Get shared request directory path
+     */
+    protected getSharedRequestPath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get history file path for a request
+     */
+    protected getHistoryFilePath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get shared history file path for a request
+     */
+    protected getSharedHistoryFilePath(environment: string, requestPath: string, requestId: string): string;
+    /**
+     * Get full response file path
+     */
+    protected getResponseFilePath(environment: string, requestPath: string, requestId: string, entryId: string): string;
+    /**
+     * Get shared full response file path
+     */
+    protected getSharedResponseFilePath(environment: string, requestPath: string, requestId: string, entryId: string): string;
+    /**
+     * Load history for a request
+     */
+    loadHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    /**
+     * Load shared history for a request
+     */
+    loadSharedHistory(environment: string, requestPath: string, requestId: string): RequestHistory | null;
+    /**
+     * Get history entries for a specific environment / request
+     */
+    getEntriesForEnvironment(environment: string, requestPath: string, requestId: string): HistoryEntry[];
+    /**
+     * Get history entries grouped by ticket/branch
+     */
+    getEntriesGroupedByTicket(environment: string, requestPath: string, requestId: string): Map<string, HistoryEntry[]>;
+    /**
+     * Get shared history entries grouped by ticket/branch
+     */
+    getSharedEntriesGroupedByTicket(environment: string, requestPath: string, requestId: string): Map<string, HistoryEntry[]>;
+    /**
+     * Save history for a request (internal)
+     */
+    protected saveHistory(history: RequestHistory): void;
+    /**
+     * Save shared history for a request (internal)
+     */
+    protected saveSharedHistory(history: RequestHistory): void;
+    /**
+     * Add a new entry to the history
+     */
+    addEntry(environment: string, requestPath: string, requestId: string, method: string, entry: Omit<HistoryEntry, 'id' | 'timestamp' | 'method'>): HistoryEntry;
+    /**
+     * Delete a specific entry
+     */
+    deleteEntry(environment: string, requestPath: string, requestId: string, entryId: string): boolean;
+    /**
+     * Delete a specific entry from shared history
+     */
+    deleteSharedEntry(environment: string, requestPath: string, requestId: string, entryId: string): boolean;
+    /**
+     * Move entry to shared history and remove from local history
+     */
+    shareEntry(environment: string, requestPath: string, requestId: string, entryId: string, tag: string): boolean;
+    /**
+     * Move a shared history entry to another group tag
+     */
+    moveSharedEntry(environment: string, requestPath: string, requestId: string, entryId: string, tag: string): boolean;
+    /**
+     * Rename a shared history group tag
+     */
+    renameSharedGroup(environment: string, requestPath: string, requestId: string, oldTag: string, newTag: string): boolean;
+    /**
+     * Clear all history for a request
+     */
+    clearHistory(environment: string, requestPath: string, requestId: string): void;
+    /**
+     * Save full response to a separate file
+     */
+    saveFullResponse(environment: string, requestPath: string, requestId: string, entryId: string, response: FullResponse): void;
+    /**
+     * Load full response from file
+     */
+    loadFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+    /**
+     * Load full response from shared history file
+     */
+    loadSharedFullResponse(environment: string, requestPath: string, requestId: string, entryId: string): FullResponse | null;
+}

package/dist/{implementations → history}/request-history.d.ts

@@ -7,8 +7,8 @@
  * Based on VS Code plugin's RequestHistoryService logic,
  * but adapted for storage-agnostic design.
  */
-import { FullResponse, HistoryEntry, IRequestHistory } from '../interfaces/history';
-import { HttpRequest, HttpResponse } from '../interfaces/types';
+import { HttpRequest, HttpResponse } from '../types/types';
+import { FullResponse, HistoryEntry, IRequestHistory } from './history-interfaces';
 /**
  * In-memory request history storage
  *
@@ -70,4 +70,3 @@ export declare class RequestHistoryStore implements IRequestHistory {
      */
     clearAll(): void;
 }
-//# sourceMappingURL=request-history.d.ts.map

package/dist/{implementations → http}/fetch-http-client.d.ts

@@ -4,16 +4,15 @@
  * Single Responsibility: Execute HTTP requests using fetch API
  * Dependency Inversion: Implements IHttpClient interface
  */
-import { IHttpClient } from '../interfaces';
-import { HttpRequest, HttpResponse } from '../interfaces/types';
+import { IHttpClient } from '../types/platform';
+import { HttpRequest, HttpResponse } from '../types/types';
 /**
  * HTTP client implementation using Node.js native fetch.
  * Requires Node.js 18+.
  */
 export declare class FetchHttpClient implements IHttpClient {
     /**
-     * Execute an HTTP request
+     * Send an HTTP request
      */
-    execute(request: HttpRequest): Promise<HttpResponse>;
+    send(request: HttpRequest): Promise<HttpResponse>;
 }
-//# sourceMappingURL=fetch-http-client.d.ts.map