#Tech Stack

Complete reference of tools and libraries used in the maltty CLI framework.

#Core Dependencies

#TypeScript & Build

#Functional Programming

#Validation & Types

#CLI Framework

#Testing

#Linting & Formatting

#Versioning & Publishing

#AI & Code Review

#Design Rationale

#Why ts-pattern?

TypeScript's switch statements don't provide exhaustive type narrowing. ts-pattern gives us:

• Exhaustive matching enforced at compile time
• Type narrowing based on discriminated unions
• Expression-based (returns values, not statements)
• Cleaner syntax for complex conditionals

Example:

import { match } from 'ts-pattern'

type Result<T, E> = { success: true; value: T } | { success: false; error: E }

const result = match(response)
  .with({ success: true }, ({ value }) => value)
  .with({ success: false }, ({ error }) => handleError(error))
  .exhaustive() // Compile error if cases missing

#Why es-toolkit?

Lodash is imperative and mutable. Ramda is powerful but has a steep learning curve. es-toolkit provides:

• Tree-shakeable ESM modules (smaller bundles)
• TypeScript-first design (better inference)
• Functional patterns without the Ramda complexity
• Modern ESNext features (uses native methods when available)

Example:

import { pipe, map, filter, groupBy } from 'es-toolkit'

const result = pipe(
  users,
  filter((u) => u.active),
  map((u) => ({ ...u, name: u.name.toUpperCase() })),
  groupBy((u) => u.role)
)

#Why Zod?

Runtime validation is critical for config files, CLI arguments, and API boundaries. Zod provides:

• Static type inference from schemas (no duplication)
• Composable validators (.refine(), .transform())
• Readable error messages
• Integration with Result types for error handling

Example:

import { z } from 'zod'

const configSchema = z.object({
  apiUrl: z.string().url(),
  timeout: z.number().positive().default(5000),
})

type Config = z.infer<typeof configSchema> // Inferred type

#Why Vitest?

Jest is slow and requires heavy configuration. Vitest provides:

• Native ESM support (no transpilation needed)
• Blazing fast with Vite's transformation pipeline
• Compatible with Jest's API (easy migration)
• First-class TypeScript support
• Watch mode that actually works

#Why OXC?

ESLint is slow on large codebases. OXC (Oxidation Compiler) is:

• Written in Rust (50-100x faster than ESLint)
• Drop-in replacement for ESLint
• Better error messages
• Lower memory usage
• Active development by the Rspack team

#Version Requirements

#Excluded Technologies

These technologies are not used in this codebase:

#References

• Architecture for how these tools fit together
• TypeScript Coding Style for usage patterns
• TypeScript Utilities for es-toolkit patterns