or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

cli-interface.mdconfiguration.mdindex.mdprogrammatic-api.md
tile.json

tessl/npm-xo

JavaScript/TypeScript linter (ESLint wrapper) with great defaults

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/xo@1.2.x

To install, run

npx @tessl/cli install tessl/npm-xo@1.2.0

index.mddocs/

XO

XO is a zero-configuration JavaScript and TypeScript linter built as an opinionated ESLint wrapper that enforces strict and readable code standards. It provides beautiful output, automatic file discovery, TypeScript support by default, and includes many useful ESLint plugins like unicorn, import, ava, and n. XO is designed for maximum developer productivity by eliminating configuration decisions while maintaining flexibility through flat config customization when needed.

Package Information

  • Package Name: xo
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install xo
  • Node.js Version: >=20.17

Core Imports

import Xo, { 
  allFilesGlob, 
  jsFilesGlob, 
  tsFilesGlob, 
  type FlatXoConfig, 
  type XoConfigItem 
} from "xo";

For CommonJS:

const Xo = require("xo").default;
const { allFilesGlob, jsFilesGlob, tsFilesGlob } = require("xo");

Basic Usage

CLI Usage

# Lint all supported files in current directory
xo

# Lint specific files
xo index.js src/*.ts

# Auto-fix issues
xo --fix

# Use spaces instead of tabs
xo --space

# Enable React support
xo --react

Programmatic Usage

import Xo from "xo";

// Create XO instance
const xo = new Xo(
  { cwd: process.cwd(), fix: false },
  { space: true, semicolon: true }
);

// Lint files
const result = await xo.lintFiles("src/**/*.{js,ts}");
console.log(`Found ${result.errorCount} errors, ${result.warningCount} warnings`);

// Lint text
const textResult = await xo.lintText("console.log('hello')", { filePath: "test.js" });

Architecture

XO is built around several key components:

  • Xo Class: Main linting engine that wraps ESLint with opinionated defaults
  • Configuration System: Flat config support with XO-specific options layered on top
  • CLI Interface: Command-line tool with comprehensive options for development workflows
  • Type System: Full TypeScript integration with comprehensive type definitions
  • Plugin Integration: Pre-configured ESLint plugins for comprehensive code quality rules
  • Cache Management: Built-in caching system for improved performance on large codebases

Capabilities

Programmatic Linting

The core XO class provides comprehensive linting functionality for JavaScript and TypeScript files, with support for both file-based and text-based linting operations.

class Xo {
  constructor(linterOptions: LinterOptions, baseXoConfig?: XoConfigOptions);
  lintFiles(globs?: string | string[]): Promise<XoLintResult>;
  lintText(code: string, options: LintTextOptions): Promise<XoLintResult>;
  calculateConfigForFile(filePath: string): Promise<Linter.Config>;
  getFormatter(name: string): Promise<ESLint.Formatter>;
  initEslint(files?: string[]): Promise<void>;
}

// Static methods for convenience
static lintText(code: string, options: LintTextOptions & LinterOptions & XoConfigOptions): Promise<XoLintResult>;
static lintFiles(globs: string | undefined, options: LinterOptions & XoConfigOptions): Promise<XoLintResult>;
static outputFixes(results: XoLintResult): Promise<void>;
static xoToEslintConfig(flatXoConfig: XoConfigItem[], options?: CreateConfigOptions): Linter.Config[];

Programmatic API

CLI Tool

Command-line interface providing comprehensive linting capabilities with auto-fixing, reporter options, configuration overrides, and editor integration.

// CLI flags and their types
interface CliFlags {
  fix: boolean;          // Auto-fix issues
  reporter?: string;     // Custom reporter
  space?: string;        // Space indentation config
  semicolon: boolean;    // Semicolon enforcement
  prettier: boolean;     // Prettier integration
  react: boolean;        // React-specific rules
  quiet: boolean;        // Show only errors
  stdin: boolean;        // Read from stdin
  open: boolean;         // Open files in editor
  ignores: string[];     // Ignore patterns
  cwd: string;          // Working directory
}

CLI Interface

Configuration

XO configuration system supporting flat config files, CLI options, and programmatic configuration with TypeScript support.

interface XoConfigOptions {
  space?: boolean | number | string;
  semicolon?: boolean;
  prettier?: boolean | 'compat';
  react?: boolean;
  ignores?: string | string[];
}

interface XoConfigItem extends XoConfigOptions {
  files?: string | string[];
  ignores?: string | string[];
  // ... extends Linter.Config
}

type FlatXoConfig = XoConfigItem | XoConfigItem[];

Configuration

File Pattern Constants

// Exported glob patterns for file matching
const jsFilesGlob = "**/*.{js,jsx,mjs,cjs}";
const tsFilesGlob = "**/*.{ts,tsx,cts,mts}";
const allFilesGlob = "**/*.{js,jsx,mjs,cjs,ts,tsx,cts,mts}";

Lint Result Type

interface XoLintResult {
  errorCount: number;
  warningCount: number;
  fixableErrorCount: number;
  fixableWarningCount: number;
  results: ESLint.LintResult[];
  rulesMeta: Record<string, Rule.RuleMetaData>;
}

interface CreateConfigOptions {
  prettierOptions?: Options;
}

// Utility types
type Space = boolean | number | string | undefined;