Print & Output

/**
 * Print informational message in default color
 * @param message - Message to display
 */
info(message: any): void;

/**
 * Print warning message in yellow
 * @param message - Warning message to display
 */
warning(message: any): void;

/**
 * Print success message in green
 * @param message - Success message to display
 */
success(message: any): void;

/**
 * Print highlighted message in cyan
 * @param message - Message to highlight
 */
highlight(message: any): void;

/**
 * Print muted message in grey
 * @param message - Muted message to display
 */
muted(message: any): void;

/**
 * Print error message in red
 * @param message - Error message to display
 */
error(message: any): void;

/**
 * Print debug information with optional title
 * @param value - Value to debug print
 * @param title - Optional title for debug output
 */
debug(value: any, title?: string): void;

import { print } from "gluegun";

// Semantic messages
print.info("Processing files...");
print.success("✓ Build completed successfully");
print.warning("⚠ Config file not found, using defaults");
print.error("✗ Failed to connect to server");
print.highlight("Important: Review these changes");
print.muted("Debug: Internal state updated");

// Debug output
print.debug({ users: 42, active: true }, "App Stats");

/**
 * Print a visual divider line
 */
divider(): void;

/**
 * Print a newline character
 */
newline(): void;

/**
 * Green checkmark symbol
 */
checkmark: string;

/**
 * Red X mark symbol  
 */
xmark: string;

import { print } from "gluegun";

print.info("Starting operations...");
print.divider();
print.success(`${print.checkmark} Step 1 completed`);
print.success(`${print.checkmark} Step 2 completed`);
print.error(`${print.xmark} Step 3 failed`);
print.newline();
print.info("Operations finished");

/**
 * Color system with all colors.js functions plus theme extensions
 */
colors: GluegunPrintColors;

interface GluegunPrintColors {
  // Standard colors.js functions
  red(text: string): string;
  green(text: string): string;
  yellow(text: string): string;
  blue(text: string): string;
  magenta(text: string): string;
  cyan(text: string): string;
  white(text: string): string;
  gray(text: string): string;
  grey(text: string): string;
  
  // Text styles
  bold(text: string): string;
  dim(text: string): string;
  italic(text: string): string;
  underline(text: string): string;
  strikethrough(text: string): string;
  
  // Background colors
  bgRed(text: string): string;
  bgGreen(text: string): string;
  bgYellow(text: string): string;
  bgBlue(text: string): string;
  bgMagenta(text: string): string;
  bgCyan(text: string): string;
  bgWhite(text: string): string;
  
  // Gluegun theme extensions
  muted(text: string): string;
  highlight(text: string): string;
  info(text: string): string;
  warning(text: string): string;
  success(text: string): string;
  error(text: string): string;
}

import { print } from "gluegun";

// Direct color usage
console.log(print.colors.red("Error occurred"));
console.log(print.colors.green("Success!"));
console.log(print.colors.blue.bold("Important Notice"));

// Combined styling
const styled = print.colors.yellow.bold.underline("Highlighted Text");
console.log(styled);

// Theme colors
console.log(print.colors.success("Operation completed"));
console.log(print.colors.warning("Check configuration"));
console.log(print.colors.muted("Debug information"));

/**
 * Print formatted table from 2D string array
 * @param data - 2D array of strings representing table data
 * @param options - Table formatting options
 */
table(data: string[][], options?: GluegunPrintTableOptions): void;

interface GluegunPrintTableOptions {
  /** Table format style */
  format?: 'markdown' | 'lean' | 'default';
  /** Additional styling options */
  style?: {
    'padding-left'?: number;
    'padding-right'?: number;
    head?: string[];
    border?: string[];
  };
}

import { print } from "gluegun";

// Basic table
const data = [
  ["Name", "Age", "City"],
  ["Alice", "25", "New York"],
  ["Bob", "30", "Los Angeles"],
  ["Charlie", "28", "Chicago"]
];

print.table(data);

// Markdown format table
print.table(data, { format: 'markdown' });

// Styled table
print.table(data, {
  format: 'default',
  style: {
    'padding-left': 2,
    'padding-right': 2,
    head: ['cyan', 'cyan', 'cyan'],
    border: ['gray']
  }
});

/**
 * Create and control loading spinner
 * @param options - Spinner text or configuration object
 * @returns Spinner instance with control methods
 */
spin(options?: string | {
  text?: string;
  spinner?: string | object;
  color?: string;
  interval?: number;
}): {
  start(): void;
  stop(): void;
  succeed(text?: string): void;
  fail(text?: string): void;
  warn(text?: string): void;
  info(text?: string): void;
  text: string;
  color: string;
};

import { print } from "gluegun";

// Simple spinner
const spinner = print.spin("Loading...");
setTimeout(() => {
  spinner.succeed("Loaded successfully!");
}, 2000);

// Configured spinner
const configSpinner = print.spin({
  text: "Processing data...",
  color: "cyan",
  spinner: "dots"
});

// Simulate async operation
async function processData() {
  configSpinner.start();
  try {
    await someAsyncOperation();
    configSpinner.succeed("Data processed successfully");
  } catch (error) {
    configSpinner.fail(`Processing failed: ${error.message}`);
  }
}

/**
 * Print comprehensive help information for the CLI
 * @param toolbox - Current toolbox context
 */
printHelp(toolbox: GluegunToolbox): void;

/**
 * Print formatted list of available commands
 * @param toolbox - Current toolbox context
 * @param commandRoot - Optional command path filter
 */
printCommands(toolbox: GluegunToolbox, commandRoot?: string[]): void;

// In a help command
export = {
  name: "help",
  run: async (toolbox) => {
    const { print } = toolbox;
    
    // Print full CLI help
    print.printHelp(toolbox);
    
    // Or print just commands
    print.printCommands(toolbox);
  }
};

/**
 * Calculate column widths for table formatting
 * @param cliTable - CLI table instance
 * @returns Array of column widths
 */
findWidths(cliTable: any): number[];

/**
 * Generate column header dividers
 * @param cliTable - CLI table instance  
 * @param style - Style configuration
 * @returns Array of divider strings
 */
columnHeaderDivider(cliTable: any, style: any): string[];

/**
 * Print without theme formatting (deprecated)
 * @param value - String to print
 */
fancy(value: string): void;

interface GluegunPrint {
  // Color system
  colors: GluegunPrintColors;
  
  // Symbols
  checkmark: string;
  xmark: string;
  
  // Basic output
  info(message: any): void;
  warning(message: any): void;
  success(message: any): void;
  highlight(message: any): void;
  muted(message: any): void;
  error(message: any): void;
  debug(value: any, title?: string): void;
  
  // Formatting
  divider(): void;
  newline(): void;
  fancy(value: string): void;
  
  // Tables
  table(data: string[][], options?: GluegunPrintTableOptions): void;
  
  // Spinners
  spin(options?: string | object): any;
  
  // Help system
  printHelp(toolbox: GluegunToolbox): void;
  printCommands(toolbox: GluegunToolbox, commandRoot?: string[]): void;
  
  // Advanced formatting
  findWidths(cliTable: any): number[];
  columnHeaderDivider(cliTable: any, style: any): string[];
}

import { build } from "gluegun";

const cli = build("my-app")
  .src(`${__dirname}/commands`)
  .help()
  .version()
  .create();

// Example command using all print features
export = {
  name: "deploy",
  description: "Deploy application to server",
  run: async (toolbox) => {
    const { print, system } = toolbox;
    
    print.info("Starting deployment process...");
    print.divider();
    
    const spinner = print.spin("Connecting to server...");
    
    try {
      // Simulate deployment steps
      await system.run("npm run build");
      spinner.succeed("Build completed");
      
      const deploySpinner = print.spin("Uploading files...");
      await system.run("rsync -av dist/ server:/var/www/");
      deploySpinner.succeed("Files uploaded");
      
      print.newline();
      print.success(`${print.checkmark} Deployment completed successfully!`);
      
      // Show deployment summary table
      const summaryData = [
        ["Step", "Status", "Time"],
        ["Build", "✓ Success", "1.2s"],
        ["Upload", "✓ Success", "3.4s"],
        ["Total", "✓ Complete", "4.6s"]
      ];
      
      print.table(summaryData, { format: 'default' });
      
    } catch (error) {
      spinner.fail("Deployment failed");
      print.error(`${print.xmark} Error: ${error.message}`);
      process.exit(1);
    }
  }
};