@ts-cloud/core 0.2.3 → 0.2.5

package/dist/cli/progress.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Progress tracking with ETA and status updates
+ * Provides interactive progress bars and status indicators
+ */
+export interface ProgressOptions {
+    total: number;
+    current?: number;
+    width?: number;
+    format?: string;
+    message?: string;
+    showETA?: boolean;
+    showPercentage?: boolean;
+    showCounter?: boolean;
+}
+/**
+ * Progress bar with ETA calculation
+ */
+export declare class ProgressBar {
+    private total;
+    private current;
+    private width;
+    private format;
+    private message;
+    private showETA;
+    private showPercentage;
+    private showCounter;
+    private startTime;
+    private lastUpdate;
+    constructor(options: ProgressOptions);
+    /**
+     * Update progress
+     */
+    tick(amount?: number): void;
+    /**
+     * Set progress to specific value
+     */
+    update(current: number): void;
+    /**
+     * Set message
+     */
+    setMessage(message: string): void;
+    /**
+     * Get current progress percentage
+     */
+    getPercentage(): number;
+    /**
+     * Calculate ETA in milliseconds
+     */
+    getETA(): number;
+    /**
+     * Format ETA as human-readable string
+     */
+    getETAFormatted(): string;
+    /**
+     * Render progress bar
+     */
+    render(): string;
+    /**
+     * Check if complete
+     */
+    isComplete(): boolean;
+}
+/**
+ * Multi-step progress tracker
+ */
+export interface Step {
+    name: string;
+    status: 'pending' | 'active' | 'completed' | 'failed' | 'skipped';
+    message?: string;
+    error?: string;
+}
+export declare class MultiStepProgress {
+    private steps;
+    private currentStepIndex;
+    constructor(stepNames: string[]);
+    /**
+     * Start a step
+     */
+    startStep(index: number, message?: string): void;
+    /**
+     * Complete current step
+     */
+    completeStep(message?: string): void;
+    /**
+     * Fail current step
+     */
+    failStep(error: string): void;
+    /**
+     * Skip current step
+     */
+    skipStep(message?: string): void;
+    /**
+     * Get step by index
+     */
+    getStep(index: number): Step | undefined;
+    /**
+     * Get all steps
+     */
+    getSteps(): Step[];
+    /**
+     * Render progress
+     */
+    render(): string;
+    /**
+     * Get status icon
+     */
+    private getStatusIcon;
+    /**
+     * Check if all steps complete
+     */
+    isComplete(): boolean;
+    /**
+     * Check if any step failed
+     */
+    hasFailed(): boolean;
+}
+/**
+ * Spinner for indeterminate progress
+ */
+export declare class Spinner {
+    private frames;
+    private currentFrame;
+    private message;
+    private interval;
+    constructor(message?: string);
+    /**
+     * Start spinner
+     */
+    start(): void;
+    /**
+     * Stop spinner
+     */
+    stop(): void;
+    /**
+     * Set message
+     */
+    setMessage(message: string): void;
+    /**
+     * Render current frame
+     */
+    render(): string;
+    /**
+     * Succeed with checkmark
+     */
+    succeed(message?: string): string;
+    /**
+     * Fail with X
+     */
+    fail(message?: string): string;
+    /**
+     * Warn with exclamation
+     */
+    warn(message?: string): string;
+    /**
+     * Info with i
+     */
+    info(message?: string): string;
+}
+/**
+ * Task list with status tracking
+ */
+export interface Task {
+    title: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    output?: string;
+}
+export declare class TaskList {
+    private tasks;
+    /**
+     * Add task
+     */
+    add(title: string): number;
+    /**
+     * Start task
+     */
+    start(index: number): void;
+    /**
+     * Complete task
+     */
+    complete(index: number, output?: string): void;
+    /**
+     * Fail task
+     */
+    fail(index: number, output?: string): void;
+    /**
+     * Render task list
+     */
+    render(): string;
+    /**
+     * Get status icon
+     */
+    private getStatusIcon;
+}

package/dist/cli/repl.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Interactive REPL mode for ts-cloud CLI
+ * Provides a shell-like experience for running commands
+ */
+export interface REPLOptions {
+    prompt?: string;
+    welcome?: string;
+    commands: Map<string, REPLCommand>;
+    historyFile?: string;
+    autocomplete?: boolean;
+}
+export interface REPLCommand {
+    name: string;
+    description: string;
+    aliases?: string[];
+    handler: (args: string[]) => Promise<void> | void;
+    autocomplete?: (partial: string) => string[];
+}
+export interface REPLHistory {
+    commands: string[];
+    maxSize: number;
+}
+/**
+ * REPL session manager
+ */
+export declare class REPL {
+    private options;
+    private running;
+    private history;
+    private historyIndex;
+    constructor(options: REPLOptions);
+    /**
+     * Start REPL session
+     */
+    start(): Promise<void>;
+    /**
+     * Stop REPL session
+     */
+    stop(): void;
+    /**
+     * Read input from user
+     */
+    private readInput;
+    /**
+     * Execute command
+     */
+    private executeCommand;
+    /**
+     * Parse command input
+     */
+    private parseCommand;
+    /**
+     * Find command by name or alias
+     */
+    private findCommand;
+    /**
+     * Show help message
+     */
+    private showHelp;
+    /**
+     * Show command history
+     */
+    private showHistory;
+    /**
+     * Add command to history
+     */
+    private addToHistory;
+    /**
+     * Navigate history (up arrow)
+     */
+    private historyBack;
+    /**
+     * Navigate history (down arrow)
+     */
+    private historyForward;
+    /**
+     * Autocomplete command
+     */
+    private autocomplete;
+    /**
+     * Load history from file
+     */
+    private loadHistory;
+    /**
+     * Save history to file
+     */
+    private saveHistory;
+    /**
+     * Search history
+     */
+    searchHistory(query: string): string[];
+    /**
+     * Clear history
+     */
+    clearHistory(): void;
+}
+/**
+ * Context manager for REPL sessions
+ * Maintains state across commands
+ */
+export declare class REPLContext {
+    private variables;
+    private workingDirectory;
+    /**
+     * Set variable
+     */
+    set(key: string, value: any): void;
+    /**
+     * Get variable
+     */
+    get(key: string): any;
+    /**
+     * Check if variable exists
+     */
+    has(key: string): boolean;
+    /**
+     * Delete variable
+     */
+    delete(key: string): void;
+    /**
+     * Get all variables
+     */
+    getAll(): Record<string, any>;
+    /**
+     * Clear all variables
+     */
+    clear(): void;
+    /**
+     * Set working directory
+     */
+    setWorkingDirectory(path: string): void;
+    /**
+     * Get working directory
+     */
+    getWorkingDirectory(): string;
+}
+/**
+ * Command builder for creating REPL commands
+ */
+export declare class REPLCommandBuilder {
+    private command;
+    name(name: string): this;
+    description(description: string): this;
+    aliases(...aliases: string[]): this;
+    handler(handler: (args: string[]) => Promise<void> | void): this;
+    autocomplete(fn: (partial: string) => string[]): this;
+    build(): REPLCommand;
+}

package/dist/cli/suggestions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Command suggestions and typo corrections
+ * Helps users discover commands and fix typos
+ */
+/**
+ * Suggest similar commands based on typo
+ */
+export declare function suggestCommand(input: string, availableCommands: string[], threshold?: number): string[];
+/**
+ * Format suggestion message
+ */
+export declare function formatSuggestion(input: string, suggestions: string[]): string;
+/**
+ * Check if input is likely a typo of any available command
+ */
+export declare function isLikelyTypo(input: string, availableCommands: string[]): boolean;
+/**
+ * Command categories for contextual help
+ */
+export interface CommandCategory {
+    name: string;
+    description: string;
+    commands: CommandInfo[];
+}
+export interface CommandInfo {
+    name: string;
+    description: string;
+    aliases?: string[];
+    examples?: string[];
+}
+/**
+ * Get contextual help based on current command
+ */
+export declare function getContextualHelp(currentCommand: string, categories: CommandCategory[]): string;
+/**
+ * Search commands by keyword
+ */
+export declare function searchCommands(query: string, categories: CommandCategory[]): Array<{
+    command: CommandInfo;
+    category: string;
+}>;
+/**
+ * Autocomplete suggestions for partial input
+ */
+export declare function autocomplete(partial: string, availableCommands: string[], maxResults?: number): string[];
+/**
+ * Suggest flags based on partial input
+ */
+export interface FlagInfo {
+    name: string;
+    alias?: string;
+    description: string;
+    type: 'boolean' | 'string' | 'number';
+    required?: boolean;
+}
+export declare function suggestFlags(partial: string, availableFlags: FlagInfo[]): FlagInfo[];
+/**
+ * Format flag suggestions
+ */
+export declare function formatFlagSuggestions(flags: FlagInfo[]): string;
+/**
+ * Get command usage example
+ */
+export declare function getCommandUsage(command: CommandInfo): string;
+/**
+ * Validate command and suggest fixes
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    suggestions: string[];
+}
+export declare function validateCommand(input: string, availableCommands: string[], requiredFlags?: string[]): ValidationResult;

package/dist/cli/table.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Table formatting utilities for CLI output
+ * Better table rendering with borders, alignment, colors
+ */
+export interface TableColumn {
+    key: string;
+    label: string;
+    width?: number;
+    align?: 'left' | 'right' | 'center';
+    formatter?: (value: any) => string;
+}
+export interface TableOptions {
+    columns: TableColumn[];
+    data: Record<string, any>[];
+    border?: boolean;
+    header?: boolean;
+    compact?: boolean;
+    maxWidth?: number;
+}
+/**
+ * Format data as a table
+ */
+export declare function formatTable(options: TableOptions): string;
+/**
+ * Format data as a tree structure
+ */
+export interface TreeNode {
+    label: string;
+    children?: TreeNode[];
+    metadata?: Record<string, any>;
+}
+export interface TreeOptions {
+    indent?: string;
+    showMetadata?: boolean;
+}
+/**
+ * Format data as a tree
+ */
+export declare function formatTree(nodes: TreeNode[], options?: TreeOptions): string;
+/**
+ * Create a simple progress bar
+ */
+export interface ProgressBarOptions {
+    total: number;
+    current: number;
+    width?: number;
+    format?: string;
+    complete?: string;
+    incomplete?: string;
+}
+/**
+ * Format a progress bar
+ */
+export declare function formatProgressBar(options: ProgressBarOptions): string;
+/**
+ * Format bytes as human-readable size
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Format duration as human-readable time
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format list with bullets
+ */
+export declare function formatList(items: string[], bullet?: string): string;
+/**
+ * Format key-value pairs
+ */
+export declare function formatKeyValue(data: Record<string, any>, options?: {
+    indent?: string;
+    separator?: string;
+}): string;

package/dist/cli/table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cloudformation/builder.d.ts

@@ -0,0 +1,93 @@
+import type { CloudConfig } from '../types';
+import type { CloudFormationTemplate, CloudFormationResource } from './types';
+/**
+ * CloudFormation Template Builder
+ * Converts-cloudConfig to CloudFormation templates
+ */
+export declare class CloudFormationBuilder {
+    protected template: CloudFormationTemplate;
+    private config;
+    private resourceDependencies;
+    constructor(config: CloudConfig);
+    /**
+     * Build the complete CloudFormation template
+     */
+    build(): CloudFormationTemplate;
+    /**
+     * Add parameters to the template
+     */
+    private addParameters;
+    /**
+     * Add mappings to the template
+     */
+    private addMappings;
+    /**
+     * Add conditions to the template
+     */
+    private addConditions;
+    /**
+     * Add all resources to the template
+     */
+    private addResources;
+    /**
+     * Initialize default outputs in the template
+     */
+    private initializeOutputs;
+    /**
+     * Add a resource to the template
+     */
+    addResource(logicalId: string, type: string, properties: Record<string, any>, options?: {
+        dependsOn?: string | string[];
+        condition?: string;
+        deletionPolicy?: 'Delete' | 'Retain' | 'Snapshot';
+        updateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot';
+    }): void;
+    /**
+     * Add or merge outputs to the template
+     */
+    addOutputs(outputs: Record<string, any>): void;
+    /**
+     * Get the current outputs
+     */
+    getOutputs(): Record<string, any>;
+    /**
+     * Check if a resource exists in the template
+     */
+    hasResource(logicalId: string): boolean;
+    /**
+     * Get a resource from the template
+     */
+    getResource(logicalId: string): CloudFormationResource | undefined;
+    /**
+     * Track resource dependencies for cycle detection
+     */
+    private trackDependency;
+    /**
+     * Resolve and validate resource dependencies
+     * Detects circular dependencies and reorders if needed
+     */
+    private resolveDependencies;
+    /**
+     * Generate a logical ID from a name
+     */
+    toLogicalId(name: string): string;
+    /**
+     * Call resource builder functions
+     */
+    private addNetworkResources;
+    private addStorageResources;
+    private addComputeResources;
+    private addDatabaseResources;
+    private addFunctionResources;
+    private addCacheResources;
+    private addQueueResources;
+    private addMessagingResources;
+    private addCDNResources;
+    private addApiGatewayResources;
+    private addMonitoringResources;
+    private addSecurityResources;
+}
+/**
+ * Main function to convert CloudConfig to CloudFormation template
+ */
+export declare function buildCloudFormationTemplate(config: CloudConfig): CloudFormationTemplate;

package/dist/cloudformation/builder.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * CloudFormation Builder Tests
+ */
+export {};

package/dist/cloudformation/builders/api-gateway.d.ts

@@ -0,0 +1,30 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface ApiGatewayConfig {
+    type: 'http' | 'rest' | 'websocket';
+    customDomain?: {
+        domain: string;
+        certificateArn: string;
+    };
+    cors?: {
+        allowOrigins: string[];
+        allowMethods: string[];
+        allowHeaders?: string[];
+        maxAge?: number;
+    };
+    throttling?: {
+        rateLimit: number;
+        burstLimit: number;
+    };
+    routes?: any;
+    authorizer?: {
+        type: 'jwt' | 'lambda' | 'cognito';
+        identitySource?: string;
+        authorizerUri?: string;
+        issuer?: string;
+        audience?: string[];
+    };
+}
+/**
+ * Add API Gateway resources to CloudFormation template
+ */
+export declare function addApiGatewayResources(builder: CloudFormationBuilder, config: ApiGatewayConfig): void;

package/dist/cloudformation/builders/cache.d.ts

@@ -0,0 +1,35 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface CacheConfig {
+    redis?: {
+        nodeType: string;
+        numCacheNodes: number;
+        engine: 'redis';
+        engineVersion: string;
+        port?: number;
+        parameterGroup?: {
+            maxmemoryPolicy?: string;
+            timeout?: string;
+            [key: string]: string | undefined;
+        };
+        snapshotRetentionLimit?: number;
+        snapshotWindow?: string;
+        automaticFailoverEnabled?: boolean;
+    };
+    memcached?: {
+        nodeType: string;
+        numCacheNodes: number;
+        engine: 'memcached';
+        engineVersion: string;
+        port?: number;
+    };
+    elasticache?: {
+        nodeType: string;
+        numCacheNodes: number;
+        engine: string;
+        engineVersion: string;
+    };
+}
+/**
+ * Add ElastiCache resources to CloudFormation template
+ */
+export declare function addCacheResources(builder: CloudFormationBuilder, config: CacheConfig): void;

package/dist/cloudformation/builders/cdn.d.ts

@@ -0,0 +1,34 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface CDNConfig {
+    enabled: boolean;
+    origins?: Array<{
+        id: string;
+        domainName: string;
+        pathPattern?: string;
+        originPath?: string;
+    }>;
+    customDomain?: {
+        domain: string;
+        certificateArn: string;
+    };
+    cachePolicy?: {
+        minTTL?: number;
+        defaultTTL?: number;
+        maxTTL?: number;
+    };
+    compress?: boolean;
+    http3?: boolean;
+    errorPages?: {
+        [code: string]: string;
+    };
+    edgeFunctions?: Array<{
+        eventType: 'viewer-request' | 'viewer-response' | 'origin-request' | 'origin-response';
+        functionArn: string;
+        name: string;
+    }>;
+    priceClass?: 'PriceClass_All' | 'PriceClass_200' | 'PriceClass_100';
+}
+/**
+ * Add CloudFront distribution to CloudFormation template
+ */
+export declare function addCDNResources(builder: CloudFormationBuilder, config: CDNConfig): void;