atmn

atmn is the official CLI for Autumn, an open-source pricing and billing platform. It lets teams define features, plans, and pricing logic in a typed autumn.config.ts file, then sync that configuration to Autumn’s API with atmn push or fetch remote changes back into the codebase with atmn pull. This keeps pricing changes reviewable through normal version control instead of being made ad hoc through a dashboard.

Beyond config sync, atmn ships an interactive terminal UI (built on Ink and React) for browsing customers, plans, features, and usage events, plus a headless mode that emits JSON or CSV for CI pipelines and AI agents. OAuth-based login, scaffolding templates for common billing models (credit systems, seat-based plans, usage tiers), and generated TypeScript SDK types round out the workflow from local development through production deploys.

What You Get

• Typed autumn.config.ts builders (feature, plan, item, reward, referralProgram) for defining pricing entirely in code
• atmn push / atmn pull to sync config with Autumn and generate TypeScript SDK types automatically
• An Ink-powered interactive terminal UI for browsing customers, plans, features, and usage events
• Headless mode with JSON/CSV output for CI pipelines and AI coding agents
• OAuth login flow plus starter templates for common pricing models (credit systems, seat-based, usage-based)

Common Use Cases

• Reviewing pricing changes through pull requests instead of a billing dashboard
• Bootstrapping a new project’s pricing model from a starter template (OpenAI-style credits, seat-based SaaS, usage tiers)
• Auditing customers, plans, and usage events from the terminal without opening a web UI
• Wiring atmn push —prod —yes into a CI/CD pipeline to deploy pricing changes automatically
• Letting an AI coding agent inspect and modify pricing config in headless mode

Under The Hood

Architecture The CLI is built around Commander.js for command routing (src/cli.tsx), which dynamically imports either an Ink/React interactive view (src/views/react/) or a headless handler (src/commands/) depending on TTY detection — the same push/pull/customers/etc. logic is split into presentation (Ink views) versus headless execution paths (src/lib/headless, src/commands), letting one CLI surface serve both humans and CI/agents. Config authoring flows through src/compose (builder functions like plan(), feature(), item() that attach non-enumerable __atmnType tags for later dispatch) into src/lib/transforms for diffing and codegen, while src/lib/api/client.ts centralizes all HTTP calls to Autumn’s backend. Global flags (-p/-l/—headless) are threaded through a module-level cliContext set once in a Commander preAction hook rather than passed explicitly — pragmatic, but an implicit form of shared state that every command handler depends on.

Tech Stack TypeScript in strict mode targeting Node >=16, built with a custom tsup-based bun.config.ts producing a single dist/cli.js binary. Command parsing uses commander, interactive rendering uses ink plus react and a family of ink-* widget packages (ink-table, ink-select-input, ink-scroll-view, ink-big-text), with @tanstack/react-query handling data fetching inside the terminal views. HTTP calls go through axios, OAuth via arctic, schema validation via zod, prompts via @inquirer/prompts, and local settings persistence via conf. Tests run on Bun’s built-in test runner combined with cli-testing-library for spawning and asserting against the compiled binary. Linting is handled by Biome, though legacy xo/ava/prettier devDependencies remain from an earlier tooling setup. The package lives inside a Bun/Turborepo monorepo alongside the Autumn server, shared types package, and website.

Code Quality Thirty-plus test files span test/auth, test/codegen, test/pull, test/push, test/nuke, and test/workflow — some are pure unit tests of transform/diff logic, others spawn the actual compiled CLI via cli-testing-library and assert on stdout and exit codes, giving genuine black-box coverage of command behavior rather than only mocked units. TypeScript strict mode is enabled and error handling in the CLI layer is explicit: commands catch failures, route them through a shared formatError() helper, print in red, and set non-zero exit codes instead of swallowing errors silently. Naming is consistent per file role (commands/, views/react/, lib/), and dynamic imports are used pervasively to keep cold-start fast by deferring code for rarely-used commands; a dedicated CI workflow for this package specifically wasn’t found in the portion of the monorepo inspected.

API Design The compose API (feature(), plan(), .variant()) is small and declarative — a handful of builder functions cover most pricing patterns — and atmn pull regenerates a .d.ts declaration file so IDs used in the config get type-safe autocomplete elsewhere in the app, a genuinely useful ergonomic loop where the config becomes its own typings. Push and pull invest heavily in showing a diff before mutating anything, and —yes / —dangerously-skip-all-confirmation-prompts flags make the same commands safe for both interactive and unattended use, with automatic non-TTY detection switching behavior without extra flags. Documentation is thorough and example-driven, though a first-time contributor would need to navigate a few visible rough edges, such as legacy tooling configs left alongside the current Biome setup and comments noting an in-progress pull rewrite.