curl-runner-core/dist/index.d.ts

Core library for running cURL scripts with comprehensive logging, error handling, and parallel execution capabilities. Zero external dependencies for maximum security.

/**
 * Type definitions for @curl-runner/core
 */

interface CurlResult {
  success: boolean;
  output: string;
  httpStatus?: number;
  error?: string;
  duration: number;
  parsed?: any;
}

interface LoggerConfig {
  logsDir: string;
  reportLogFile: string;
  errorLogFile: string;
}

interface ConcurrentOptions {
  batchSize?: number;
  delayBetweenBatches?: number;
}

interface CurlRunnerConfig {
  scriptsDir: string;
  logsDir: string;
  reportLogFile: string;
  errorLogFile: string;
  scriptExtension: string;
  scriptDelayMs: number;
}

interface ScriptInfo {
  name: string;
  path: string;
  extension: string;
}

interface HttpErrorInfo {
  status: number;
  category: string;
  isError: boolean;
}

declare class CurlRunner {
  constructor(scriptsDir?: string, logsDir?: string, reportsDir?: string, weeks?: number);
  runAllScripts(): Promise<CurlResult[]>;
  runAllScriptsParallel(): Promise<CurlResult[]>;
  runAllScriptsConcurrent(options?: ConcurrentOptions): Promise<CurlResult[]>;
  runScriptsWithConcurrency(scripts: string[], maxConcurrent?: number): Promise<CurlResult[]>;
  runScript(scriptName: string): Promise<CurlResult>;
  scanScripts(): Promise<ScriptInfo[]>;
  runWeeklyAnalysis(weekNumber?: number): Promise<any>;
  runMultiWeekAnalysis(): Promise<any>;
  getWeeklyReportingConfig(): any;
}

interface WeeklyReportData {
  week: number;
  scripts: Array<{
    name: string;
    results: CurlResult[];
  }>;
}

interface DataGapAnalysis {
  week: number;
  totalScripts: number;
  successfulScripts: number;
  failedScripts: number;
  dataGaps: Array<{
    script: string;
    successRate: number;
    missingData: number;
    severity: 'critical' | 'high' | 'medium';
  }>;
  errorRates: Record<string, number>;
  successRates: Record<string, number>;
  overallSuccessRate: number;
  overallErrorRate: number;
  alerts: Array<{
    type: string;
    script?: string;
    errorRate?: number;
    threshold?: number;
    severity: 'critical' | 'high' | 'medium';
  }>;
}

interface WeeklyReport {
  metadata: {
    generatedAt: string;
    week: number;
    totalWeeks: number;
    reportVersion: string;
  };
  summary: {
    totalScripts: number;
    successfulScripts: number;
    failedScripts: number;
    overallSuccessRate: number;
    overallErrorRate: number;
    dataGapsCount: number;
    alertsCount: number;
  };
  analysis: DataGapAnalysis;
  recommendations: Array<{
    priority: 'critical' | 'high' | 'medium';
    category: string;
    message: string;
    scripts?: string[];
    action: string;
  }>;
}

declare class WeeklyReporter {
  constructor(reportsDir?: string, weeks?: number);
  analyzeDataGaps(weekData: WeeklyReportData): DataGapAnalysis;
  generateWeeklyReport(weekData: WeeklyReportData): WeeklyReport;
  generateRecommendations(analysis: DataGapAnalysis): Array<{
    priority: 'critical' | 'high' | 'medium';
    category: string;
    message: string;
    scripts?: string[];
    action: string;
  }>;
  saveWeeklyReport(report: WeeklyReport): Promise<string>;
  generateSummaryReport(weeklyReports: WeeklyReport[]): any;
  saveSummaryReport(summary: any): Promise<string>;
}

declare class Logger {
  constructor(logsDir: string);
  ensureLogsDirectory(): Promise<void>;
  generateLogFilename(scriptName: string): string;
  writeLog(scriptName: string, content: string): Promise<void>;
  writeReportLog(message: string): Promise<void>;
  writeErrorLog(error: string): Promise<void>;
}

declare class CurlParser {
  parseCurlOutput(output: string): CurlResult;
  extractHttpStatus(output: string): number | null;
  isHttpError(status: number): boolean;
  getErrorCategory(status: number): string;
}

declare class FileSystem {
  scanScripts(directory: string): Promise<ScriptInfo[]>;
  fileExists(filePath: string): Promise<boolean>;
  ensureDirectory(dirPath: string): Promise<void>;
  getFileExtension(filePath: string): string;
  joinPath(...paths: string[]): string;
  getDirName(filePath: string): string;
  getBaseName(filePath: string): string;
}

declare const DEFAULT_CONFIG: CurlRunnerConfig;
declare const VERSION: string;
declare const LIBRARY_NAME: string;

// Compatibility functions
interface CompatibilityStatus {
  currentVersion: string;
  minCompatibility: {
    isCompatible: boolean;
    isMinCompatible: boolean;
    isMaxCompatible: boolean;
    minVersion: string;
    maxVersion: string;
  };
  recommendedCompatibility: {
    isCompatible: boolean;
    isMinCompatible: boolean;
    isMaxCompatible: boolean;
    minVersion: string;
    maxVersion: string;
  };
  testedCompatibility: {
    isCompatible: boolean;
    isMinCompatible: boolean;
    isMaxCompatible: boolean;
    minVersion: string;
    maxVersion: string;
  };
  isSupported: boolean;
  isRecommended: boolean;
  isTested: boolean;
}

interface CompatibilityMatrix {
  current: string;
  minimum: string;
  recommended: {
    min: string;
    max: string;
  };
  tested: {
    min: string;
    max: string;
  };
  status: {
    isSupported: boolean;
    isRecommended: boolean;
    isTested: boolean;
  };
}

interface CompatibilityOptions {
  strict?: boolean;
  warn?: boolean;
}

declare function enforceCompatibility(options?: CompatibilityOptions): CompatibilityStatus;
declare function getCompatibilityInfo(): CompatibilityStatus;
declare function isTestedVersion(): boolean;
declare function isRecommendedVersion(): boolean;
declare function getCompatibilityMatrix(): CompatibilityMatrix;

export { CurlParser, CurlRunner, DEFAULT_CONFIG, FileSystem, LIBRARY_NAME, Logger, VERSION, WeeklyReporter, enforceCompatibility, getCompatibilityInfo, getCompatibilityMatrix, isRecommendedVersion, isTestedVersion };
export type { CompatibilityMatrix, CompatibilityOptions, CompatibilityStatus, ConcurrentOptions, CurlResult, CurlRunnerConfig, DataGapAnalysis, HttpErrorInfo, LoggerConfig, ScriptInfo, WeeklyReport, WeeklyReportData };