@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/backup/manager.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Global backup manager instance
+ */
+export declare const backupManager: BackupManager;
+/**
+ * Backup & Disaster Recovery Manager
+ * Automated backup schedules and disaster recovery
+ */
+export declare interface BackupPlan {
+  id: string
+  name: string
+  schedule: string
+  retentionDays: number
+  vaultName: string
+  resources: BackupResource[]
+  lifecycle?: BackupLifecycle
+  tags?: Record<string, string>
+}
+export declare interface BackupResource {
+  resourceArn: string
+  resourceType: 'rds' | 's3' | 'ebs' | 'efs' | 'dynamodb' | 'ec2'
+  region: string
+}
+export declare interface BackupLifecycle {
+  moveTocoldStorageAfterDays?: number
+  deleteAfterDays?: number
+}
+export declare interface BackupVault {
+  name: string
+  region: string
+  encryptionKeyArn?: string
+  accessPolicy?: any
+}
+export declare interface RestoreJob {
+  id: string
+  backupId: string
+  resourceType: string
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  startTime: Date
+  endTime?: Date
+  targetRegion?: string
+  error?: string
+}
+export declare interface ContinuousBackup {
+  id: string
+  resourceId: string
+  enabled: boolean
+  retentionDays: number
+}
+/**
+ * Backup manager for automated backup and recovery
+ */
+export declare class BackupManager {
+  private backupPlans: Map<string, BackupPlan>;
+  private backupVaults: Map<string, BackupVault>;
+  private restoreJobs: Map<string, RestoreJob>;
+  private continuousBackups: Map<string, ContinuousBackup>;
+  private planCounter: any;
+  private restoreCounter: any;
+  private continuousBackupCounter: any;
+  createVault(vault: BackupVault): void;
+  getVault(name: string): BackupVault | undefined;
+  createBackupPlan(plan: Omit<BackupPlan, 'id'>): BackupPlan;
+  getBackupPlan(id: string): BackupPlan | undefined;
+  listBackupPlans(): BackupPlan[];
+  createRDSBackupPlan(options: {
+    dbInstanceArn: string
+    schedule?: string
+    retentionDays?: number
+    vaultName?: string
+  }): BackupPlan;
+  createDynamoDBBackupPlan(options: {
+    tableArn: string
+    schedule?: string
+    retentionDays?: number
+    crossRegionCopy?: string[]
+  }): BackupPlan;
+  createEFSBackupPlan(options: {
+    fileSystemArn: string
+    schedule?: string
+    retentionDays?: number
+  }): BackupPlan;
+  enableContinuousBackup(resourceId: string, retentionDays?: any): ContinuousBackup;
+  getContinuousBackup(id: string): ContinuousBackup | undefined;
+  enablePointInTimeRecovery(resourceArn: string, resourceType: 'rds' | 'dynamodb'): {
+    enabled: boolean
+    earliestRestorableTime: Date
+    latestRestorableTime: Date
+  };
+  restoreFromBackup(options: {
+    backupId: string
+    resourceType: string
+    targetRegion?: string
+  }): Promise<RestoreJob>;
+  restoreToPointInTime(options: {
+    sourceResourceArn: string
+    targetResourceName: string
+    restoreTime: Date
+    resourceType: 'rds' | 'dynamodb'
+  }): Promise<RestoreJob>;
+  getRestoreJob(id: string): RestoreJob | undefined;
+  listRestoreJobs(): RestoreJob[];
+  setupCrossRegionReplication(options: {
+    sourceVault: string
+    sourceRegion: string
+    targetRegions: string[]
+  }): void;
+  generateBackupVaultCF(vault: BackupVault): any;
+  generateBackupPlanCF(plan: BackupPlan): any;
+  generateBackupSelectionCF(plan: BackupPlan): any;
+  clear(): void;
+}

package/dist/cicd/circleci.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Generate deployment config
+ */
+export declare function generateDeploymentConfig(options?: CircleCIOptions): string;
+/**
+ * Generate multi-environment config
+ */
+export declare function generateMultiEnvConfig(options: {
+  environments: Array<{ name: string; branch: string }>
+  awsRegion?: string
+}): string;
+/**
+ * Generate scheduled workflow config
+ */
+export declare function generateScheduledConfig(options: {
+  schedule: string
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * Generate approval workflow config
+ */
+export declare function generateApprovalConfig(options: {
+  environments: string[]
+  awsRegion?: string
+}): string;
+/**
+ * Generate parallel deployment config
+ */
+export declare function generateParallelConfig(options: {
+  regions: string[]
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * CircleCI Configuration Generator
+ * Generate CI/CD pipelines for CircleCI
+ */
+export declare interface CircleCIOptions {
+  awsRegion?: string
+  dockerImage?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+  workflows?: boolean
+}

package/dist/cicd/github-actions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Generate deployment workflow
+ */
+export declare function generateDeploymentWorkflow(options?: GitHubActionsOptions): string;
+/**
+ * Generate multi-environment deployment workflow
+ */
+export declare function generateMultiEnvWorkflow(options: {
+  environments: Array<{ name: string; branch: string }>
+  awsRegion?: string
+  awsRole?: string
+}): string;
+/**
+ * Generate PR preview workflow
+ */
+export declare function generatePRPreviewWorkflow(options?: {
+  awsRegion?: string
+  awsRole?: string
+  ttl?: number
+}): string;
+/**
+ * Generate scheduled deployment workflow
+ */
+export declare function generateScheduledWorkflow(options: {
+  schedule: string
+  environment: string
+  awsRegion?: string
+  awsRole?: string
+}): string;
+/**
+ * Generate matrix deployment workflow (multiple regions/accounts)
+ */
+export declare function generateMatrixWorkflow(options: {
+  matrix: Array<{ environment: string; region: string; account?: string }>
+  awsRole?: string
+}): string;
+/**
+ * GitHub Actions Workflow Generator
+ * Generate CI/CD workflows for GitHub Actions
+ */
+export declare interface GitHubActionsOptions {
+  workflowName?: string
+  trigger?: 'push' | 'pull_request' | 'workflow_dispatch' | 'schedule'
+  branches?: string[]
+  schedule?: string
+  environments?: string[]
+  awsRegion?: string
+  awsRole?: string
+  nodeVersion?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+  lintCommand?: string
+}

package/dist/cicd/gitlab-ci.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generate deployment pipeline
+ */
+export declare function generateDeploymentPipeline(options?: GitLabCIOptions): string;
+/**
+ * Generate multi-environment pipeline
+ */
+export declare function generateMultiEnvPipeline(options: {
+  environments: Array<{ name: string; branch: string; manual?: boolean }>
+  awsRegion?: string
+}): string;
+/**
+ * Generate PR/MR preview pipeline
+ */
+export declare function generatePreviewPipeline(options?: {
+  awsRegion?: string
+  ttl?: number
+}): string;
+/**
+ * Generate scheduled pipeline
+ */
+export declare function generateScheduledPipeline(options: {
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * Generate manual deployment pipeline
+ */
+export declare function generateManualPipeline(options: {
+  environments: string[]
+  awsRegion?: string
+}): string;
+/**
+ * GitLab CI/CD Pipeline Generator
+ * Generate CI/CD pipelines for GitLab
+ */
+export declare interface GitLabCIOptions {
+  stages?: string[]
+  environments?: string[]
+  awsRegion?: string
+  dockerImage?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+}

package/dist/cicd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './github-actions';
+export * from './gitlab-ci';
+export * from './circleci';

package/dist/cli/history.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Format history for display
+ */
+export declare function formatHistory(entries: HistoryEntry[], options?: { maxWidth?: number }): string;
+/**
+ * Format history statistics
+ */
+export declare function formatHistoryStats(stats: ReturnType<CommandHistory['getStats']>): string;
+/**
+ * Command history with search and persistence
+ * Tracks executed commands and provides search/replay functionality
+ */
+export declare interface HistoryEntry {
+  command: string
+  timestamp: Date
+  success: boolean
+  duration?: number
+  output?: string
+}
+export declare interface HistoryOptions {
+  maxSize?: number
+  persistFile?: string
+  trackOutput?: boolean
+}
+/**
+ * Command history manager
+ */
+export declare class CommandHistory {
+  private entries: HistoryEntry[];
+  private maxSize: number;
+  private persistFile?: string;
+  private trackOutput: boolean;
+  constructor(options?: HistoryOptions);
+  add(entry: Omit<HistoryEntry, 'timestamp'>): void;
+  getAll(): HistoryEntry[];
+  getRecent(count?: number): HistoryEntry[];
+  search(query: string): HistoryEntry[];
+  searchByDate(startDate: Date, endDate: Date): HistoryEntry[];
+  getSuccessful(): HistoryEntry[];
+  getFailed(): HistoryEntry[];
+  getMostUsed(count?: number): Array<{ command: string; count: number }>;
+  getStats(): {
+    total: number
+    successful: number
+    failed: number
+    averageDuration: number
+    mostUsed: string
+  };
+  clear(): void;
+  getByIndex(index: number): HistoryEntry | undefined;
+  removeByIndex(index: number): void;
+  save(): Promise<void>;
+  load(): Promise<void>;
+  exportJSON(): string;
+  exportCSV(): string;
+  importJSON(json: string): void;
+  groupByDate(): Map<string, HistoryEntry[]>;
+  groupByCommand(): Map<string, HistoryEntry[]>;
+  replay(index: number): string | undefined;
+  getSuggestions(partial: string, limit?: number): string[];
+  analyzePatterns(): {
+    timeOfDay: Map<number, number> // hour -> count
+    dayOfWeek: Map<number, number> // day -> count
+    successRate: number
+  };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+export * from './table';
+export * from './progress';
+export * from './suggestions';
+export * from './repl';
+export * from './history';

package/dist/cli/progress.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Progress tracking with ETA and status updates
+ * Provides interactive progress bars and status indicators
+ */
+export declare interface ProgressOptions {
+  total: number
+  current?: number
+  width?: number
+  format?: string
+  message?: string
+  showETA?: boolean
+  showPercentage?: boolean
+  showCounter?: boolean
+}
+/**
+ * Multi-step progress tracker
+ */
+export declare interface Step {
+  name: string
+  status: 'pending' | 'active' | 'completed' | 'failed' | 'skipped'
+  message?: string
+  error?: string
+}
+/**
+ * Task list with status tracking
+ */
+export declare interface Task {
+  title: string
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  output?: string
+}
+/**
+ * Progress bar with ETA calculation
+ */
+export declare class ProgressBar {
+  private total: number;
+  private current: number;
+  private width: number;
+  private format: string;
+  private message: string;
+  private showETA: boolean;
+  private showPercentage: boolean;
+  private showCounter: boolean;
+  private startTime: number;
+  private lastUpdate: number;
+  constructor(options: ProgressOptions);
+  tick(amount?: number): void;
+  update(current: number): void;
+  setMessage(message: string): void;
+  getPercentage(): number;
+  getETA(): number;
+  getETAFormatted(): string;
+  render(): string;
+  isComplete(): boolean;
+}
+export declare class MultiStepProgress {
+  private steps: Step[];
+  private currentStepIndex: number;
+  constructor(stepNames: string[]);
+  startStep(index: number, message?: string): void;
+  completeStep(message?: string): void;
+  failStep(error: string): void;
+  skipStep(message?: string): void;
+  getStep(index: number): Step | undefined;
+  getSteps(): Step[];
+  render(): string;
+  private getStatusIcon(status: Step['status']): string;
+  isComplete(): boolean;
+  hasFailed(): boolean;
+}
+/**
+ * Spinner for indeterminate progress
+ */
+export declare class Spinner {
+  private frames: string[];
+  private currentFrame: number;
+  private message: string;
+  private interval: Timer | null;
+  constructor(message?: string);
+  start(): void;
+  stop(): void;
+  setMessage(message: string): void;
+  render(): string;
+  succeed(message?: string): string;
+  fail(message?: string): string;
+  warn(message?: string): string;
+  info(message?: string): string;
+}
+export declare class TaskList {
+  private tasks: Task[];
+  add(title: string): number;
+  start(index: number): void;
+  complete(index: number, output?: string): void;
+  fail(index: number, output?: string): void;
+  render(): string;
+  private getStatusIcon(status: Task['status']): string;
+}

package/dist/cli/repl.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Interactive REPL mode for ts-cloud CLI
+ * Provides a shell-like experience for running commands
+ */
+export declare interface REPLOptions {
+  prompt?: string
+  welcome?: string
+  commands: Map<string, REPLCommand>
+  historyFile?: string
+  autocomplete?: boolean
+}
+export declare interface REPLCommand {
+  name: string
+  description: string
+  aliases?: string[]
+  handler: (args: string[]) => Promise<void> | void
+  autocomplete?: (partial: string) => string[]
+}
+export declare interface REPLHistory {
+  commands: string[]
+  maxSize: number
+}
+/**
+ * REPL session manager
+ */
+export declare class REPL {
+  private options: REPLOptions;
+  private running: boolean;
+  private history: REPLHistory;
+  private historyIndex: number;
+  constructor(options: REPLOptions);
+  start(): Promise<void>;
+  stop(): void;
+  private readInput(): Promise<string>;
+  private executeCommand(input: string): Promise<void>;
+  private parseCommand(input: string): string[];
+  private findCommand(name: string): REPLCommand | undefined;
+  private showHelp(): void;
+  private showHistory(): void;
+  private addToHistory(command: string): void;
+  private historyBack(): string | undefined;
+  private historyForward(): string | undefined;
+  private autocomplete(partial: string): string[];
+  private loadHistory(): Promise<void>;
+  private saveHistory(): Promise<void>;
+  searchHistory(query: string): string[];
+  clearHistory(): void;
+}
+/**
+ * Context manager for REPL sessions
+ * Maintains state across commands
+ */
+export declare class REPLContext {
+  private variables: Map<string, any>;
+  private workingDirectory: string;
+  set(key: string, value: any): void;
+  get(key: string): any;
+  has(key: string): boolean;
+  delete(key: string): void;
+  getAll(): Record<string, any>;
+  clear(): void;
+  setWorkingDirectory(path: string): void;
+  getWorkingDirectory(): string;
+}
+/**
+ * Command builder for creating REPL commands
+ */
+export declare class REPLCommandBuilder {
+  private command: Partial<REPLCommand>;
+  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,67 @@
+/**
+ * Suggest similar commands based on typo
+ */
+export declare function suggestCommand(input: string, availableCommands: string[], threshold?: any): 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;
+/**
+ * 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?: any): string[];
+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;
+export declare function validateCommand(input: string, availableCommands: string[], requiredFlags?: string[]): ValidationResult;
+/**
+ * Command categories for contextual help
+ */
+export declare interface CommandCategory {
+  name: string
+  description: string
+  commands: CommandInfo[]
+}
+export declare interface CommandInfo {
+  name: string
+  description: string
+  aliases?: string[]
+  examples?: string[]
+}
+/**
+ * Suggest flags based on partial input
+ */
+export declare interface FlagInfo {
+  name: string
+  alias?: string
+  description: string
+  type: 'boolean' | 'string' | 'number'
+  required?: boolean
+}
+/**
+ * Validate command and suggest fixes
+ */
+export declare interface ValidationResult {
+  valid: boolean
+  errors: string[]
+  warnings: string[]
+  suggestions: string[]
+}

package/dist/cli/table.d.ts

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