Using Cobra to Build a CLI Accounting App

What is Cobra and Why Use It?

Cobra is a powerful library for building modern CLI applications in Go. Created by spf13 and maintained by the Go team, Cobra provides an elegant framework for creating command-line interfaces that follow the patterns users expect from professional tools. The library handles the complexities of argument parsing, command hierarchy, help generation, and error handling, allowing developers to focus on implementing their application's core functionality.

The architecture of Cobra revolves around the concept of commands, which represent actions users can perform, and flags, which modify how those actions behave. This hierarchical structure naturally maps to how users think about CLI tools--one command might represent the application itself, with subcommands representing specific operations. For an accounting application, this could mean a top-level command for the app, with subcommands for billing, receipts, reports, and other financial operations.

Cobra's adoption by major projects demonstrates its reliability and scalability. Tools like Docker CLI, Kubernetes kubectl, Hugo, and Istio all use Cobra for their command-line interfaces. This widespread adoption means that users familiar with any of these tools will find your Cobra-based application intuitive to use, as the patterns and conventions remain consistent across projects.

For teams looking to build robust command-line tools as part of their web development workflow, Cobra provides the foundation for creating professional-grade interfaces that integrate seamlessly with broader software ecosystems. Building CLI applications also complements modern AI automation initiatives, enabling programmatic access to business logic and data processing pipelines.

Key Features of Cobra:

• Intelligent argument parsing supporting positional arguments, flags, and subcommands
• Automatic help generation for every command and subcommand
• Sophisticated command hierarchies for organizing complex functionality
• Battle-tested by major projects like Docker, Kubernetes, and Hugo

Implementing the Billing Command

The billing command forms the core of your CLI accounting application, allowing users to create, track, and manage billable items. This command demonstrates how to structure Cobra commands with flags for customization and how to persist data between sessions. We'll implement functionality for adding new bills, viewing billing history, and managing bill status.

The billing command should support several operations that finance professionals expect: adding new bills with amounts and due dates, marking bills as paid, viewing outstanding balances, and generating billing reports. Each operation is implemented as a subcommand or controlled through flags, creating an intuitive interface that mirrors how users think about billing tasks.

First, generate a new billing command using the Cobra CLI:

cobra-cli add billing

This creates a new file cmd/billing.go with a basic command structure that you can customize. The generated command includes a Run function where you'll implement the actual billing logic. For an accounting application, this involves creating data structures for bills, integrating with a storage backend, and formatting output for display.

The parent billing command provides a logical grouping for related billing functionality and displays helpful guidance when users call it without specifying a subcommand. Each subcommand can have its own flags and arguments tailored to that specific operation:

cobra-cli add create -p billingCmd
cobra-cli add list -p billingCmd
cobra-cli add paid -p billingCmd

Each subcommand gets its own file in the cmd directory, keeping your code organized and maintainable. The -p flag specifies the parent command, establishing the hierarchical relationship between commands. This structure scales well as your application grows--adding new billing operations simply means adding new subcommands.

Creating the Bill Data Structure

Define a data structure for representing bills in your application:

type Bill struct {
 ID string `json:"id"`
 ClientName string `json:"client_name"`
 Amount float64 `json:"amount"`
 Description string `json:"description"`
 DueDate time.Time `json:"due_date"`
 Status string `json:"status"` // "pending", "paid", "overdue"
 CreatedAt time.Time `json:"created_at"`
}

This structure captures all essential information for a billable item in an accounting context. The JSON tags enable easy serialization to and from storage files, while the structured fields make it simple to generate reports and display information to users. Consider adding additional fields like invoice numbers, payment terms, or tax information as your application's requirements evolve.

Implementing the Receipt Command

Receipt tracking complements billing by recording incoming payments against outstanding bills. The receipt command allows users to record payments, associate them with specific clients, and track payment history. This two-way tracking--bills going out and payments coming in--provides the foundation for accurate financial reporting.

Create the receipt command and its subcommands to mirror the billing structure:

cobra-cli add receipt
cobra-cli add record -p receiptCmd
cobra-cli add history -p receiptCmd

The receipt command structure mirrors the billing command, with subcommands for recording new receipts and viewing payment history. Consider how receipts should link to bills--typically, a receipt records a payment that reduces an outstanding bill balance. Your data structures and command design should support this relationship cleanly.

Recording Receipts

When recording a receipt, users should specify the amount received, the client or customer making the payment, and optionally which bill the payment applies to. The implementation captures essential receipt information and provides immediate feedback to users after recording:

var recordCmd = &cobra.Command{
 Use: "record",
 Short: "Record a new receipt",
 Long: `Record a payment received from a client, optionally applying it to a specific bill.`,
 Run: func(cmd *cobra.Command, args []string) {
 receipt := Receipt{
 ID: generateID(),
 ClientName: clientName,
 Amount: amount,
 Description: description,
 ReceivedAt: time.Now(),
 }
 saveReceipt(receipt)
 fmt.Printf("Recorded receipt #%s for $%.2f from %s\n",
 receipt.ID, receipt.Amount, receipt.ClientName)
 },
}

The generateID function creates unique identifiers for each receipt, while saveReceipt handles persistent storage. Consider adding validation to ensure required fields are present and that amounts are positive before recording. This ensures data integrity and prevents common user errors.

Linking Receipts to Bills

An effective accounting system connects receipts to their corresponding bills. When recording a receipt, users can specify which bill the payment applies to, automatically updating the bill's status and outstanding balance. This linkage enables accurate aging reports and helps identify overdue invoices that need follow-up.

Adding Persistent Storage

Accounting applications require persistent storage to maintain financial records between sessions. While a production accounting system would use a proper database, a CLI application can effectively use file-based storage with JSON. This approach keeps your application simple while providing the persistence necessary for real-world use.

This storage implementation keeps data in the user's home directory within a hidden folder, following conventions used by many command-line tools. The JSON format allows easy inspection and debugging of stored data, while the MarshalIndent function creates readable output.

Storage Implementation Features:

• JSON-based storage in user's home directory
• Read and write operations for bills and receipts
• Error handling for missing or corrupted files
• Human-readable format for debugging
• Automatic storage directory creation

Building and Distributing Your Application

Once your accounting CLI is complete, build a distributable binary that users can install on their systems. Go's built-in compilation and cross-compilation capabilities allow you to build binaries for Windows, macOS, and Linux from a single codebase.

Build your application for distribution:

go build -o accounting-cli

This creates an executable binary named accounting-cli that users can run directly. To make your application globally accessible, users can place the binary in their system PATH or use Go's install command:

go install

After installation, users can run your accounting CLI from any directory without specifying the full path to the binary. This mirrors how professional tools like Docker and kubectl work and provides a polished user experience.

Whether you're building internal tools for your team or customer-facing utilities, proper web development practices ensure your CLI applications are maintainable, well-documented, and production-ready. Consider implementing comprehensive testing and documentation as part of your development workflow.

Distribution Options:

• Direct binary distribution with pre-compiled executables
• Go install for global accessibility from any terminal
• Cross-compilation for multiple platforms (Linux, macOS, Windows)
• Package management for automated installation on different systems

Sources

1. LogRocket: Using Cobra to build a CLI accounting app - Primary reference for accounting app implementation details, billing commands, and receipt recording structure.
2. Cobra.dev: Getting Started with Cobra - Official Cobra documentation covering installation, project setup, command creation, and the cobra-cli toolchain.
3. DigitalOcean: How To Use the Cobra Package in Go - Comprehensive tutorial covering CLI structure, flags, and practical implementation patterns for Go CLI development.